{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.container { width:100% !important; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.core.display import display, HTML\n",
    "display(HTML(\"<style>.container { width:100% !important; }</style>\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.optim.lr_scheduler import StepLR\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from matplotlib import cm\n",
    "import scipy.io\n",
    "import os\n",
    "from pyDOE import lhs\n",
    "import shutil\n",
    "\n",
    "import matplotlib.gridspec as gridspec\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "\n",
    "import argparse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1、基础网络结构"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "网络结构分为普通的和带残差的全连接前馈神经网络(Fully-Connected Feedforward Network)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def activation(name):\n",
    "    if name in ['tanh', 'Tanh']:\n",
    "        return nn.Tanh()\n",
    "    elif name in ['relu', 'ReLU']:\n",
    "        return nn.ReLU(inplace=True)\n",
    "    elif name in ['leaky_relu', 'LeakyReLU']:\n",
    "        return nn.LeakyReLU(inplace=True)\n",
    "    elif name in ['sigmoid', 'Sigmoid']:\n",
    "        return nn.Sigmoid()\n",
    "    elif name in ['softplus', 'Softplus']:\n",
    "        return nn.Softplus()\n",
    "    else: \n",
    "        raise ValueError(f'unknown activation function: {name}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DNN(nn.Module):\n",
    "    \"\"\"Deep Neural Network\"\"\"\n",
    "    def __init__(self, dim_in, dim_out, dim_hidden, hidden_layers, \n",
    "                 act_name='tanh', init_name=None):\n",
    "        super().__init__()\n",
    "        model = nn.Sequential()\n",
    "        \n",
    "        model.add_module('fc0', nn.Linear(dim_in, dim_hidden, bias=True))\n",
    "        model.add_module('act0', activation(act_name))\n",
    "        for i in range(1, hidden_layers):\n",
    "            model.add_module(f'fc{i}', nn.Linear(dim_hidden, dim_hidden, bias=True))\n",
    "            model.add_module(f'act{i}', activation(act_name))\n",
    "        model.add_module(f'fc{hidden_layers}', nn.Linear(dim_hidden, dim_out, bias=True))\n",
    "        \n",
    "        self.model = model\n",
    "        if init_name is not None:\n",
    "            self.init_weight(init_name)\n",
    "            \n",
    "    def init_weight(self, name):\n",
    "        if name == 'xavier_normal':\n",
    "            nn_init = nn.init.xavier_normal_\n",
    "        elif name == 'xavier_uniform':\n",
    "            nn_init = nn.init.xavier_uniform_\n",
    "        elif name == 'kaiming_normal':\n",
    "            nn_init = nn.init.kaiming_normal_\n",
    "        elif name == 'kaiming_uniform':\n",
    "            nn_init =  nn.init.kaiming_uniform_\n",
    "        else:\n",
    "            raise ValueError(f'unknown initialization function: {name}')\n",
    "    \n",
    "        for param in self.parameters():\n",
    "            if len(param.shape) > 1:\n",
    "                nn_init(param)\n",
    "                \n",
    "    def forward(self, x):\n",
    "        return self.model(x)\n",
    "    \n",
    "    def forward_test(self, x):\n",
    "        print(f\"{'input':<20}{str(x.shape):<40}\")\n",
    "        for name, module in self.model._modules.items():\n",
    "              x = module(x)\n",
    "              print(f\"{name:<20}{str(x.shape):<40}\")\n",
    "        return x              \n",
    "    \n",
    "    def model_size(self):\n",
    "        n_params = 0\n",
    "        for param in self.parameters():\n",
    "            n_params += param.numel()\n",
    "        return n_params                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DNN(\n",
      "  (model): Sequential(\n",
      "    (fc0): Linear(in_features=2, out_features=20, bias=True)\n",
      "    (act0): Tanh()\n",
      "    (fc1): Linear(in_features=20, out_features=20, bias=True)\n",
      "    (act1): Tanh()\n",
      "    (fc2): Linear(in_features=20, out_features=20, bias=True)\n",
      "    (act2): Tanh()\n",
      "    (fc3): Linear(in_features=20, out_features=20, bias=True)\n",
      "    (act3): Tanh()\n",
      "    (fc4): Linear(in_features=20, out_features=1, bias=True)\n",
      "  )\n",
      ")\n",
      "1341\n"
     ]
    }
   ],
   "source": [
    "model = DNN(2, 1, 20, 4, init_name='kaiming_normal')\n",
    "print(model)\n",
    "print(model.model_size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ResDNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResBlock(nn.Module):\n",
    "    def __init__(self, dim_in, dim_out, dim_hidden, act_name='tanh'):\n",
    "        super().__init__()\n",
    "        \n",
    "        assert(dim_in == dim_out)\n",
    "        block = nn.Sequential()\n",
    "        block.add_module('act0', activation(act_name))\n",
    "        block.add_module('fc0', nn.Linear(dim_in, dim_hidden, bias=True))\n",
    "        block.add_module('act1', activation(act_name))\n",
    "        block.add_module('fc1', nn.Linear(dim_hidden, dim_out, bias=True))\n",
    "        self.block = block\n",
    "        \n",
    "    def forward(self, x):\n",
    "        identity = x\n",
    "        out = self.block(x)\n",
    "        return identity + out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResDNN(nn.Module):\n",
    "    def __init__(self, dim_in, dim_out, dim_hidden, res_blocks, act_name='tanh', init_name='kaiming_normal'):\n",
    "        super().__init__()\n",
    "        \n",
    "        model = nn.Sequential()\n",
    "        model.add_module('fc_first', nn.Linear(dim_in, dim_hidden, bias=True))\n",
    "        for i in range(res_blocks):\n",
    "            res_block = ResBlock(dim_hidden, dim_hidden, dim_hidden, act_name=act_name)\n",
    "            model.add_module(f'res_block{i+1}', res_block)\n",
    "        model.add_module('act_last', activation(act_name))\n",
    "        model.add_module('fc_last', nn.Linear(dim_hidden, dim_out, bias=True))\n",
    "        \n",
    "        self.model = model\n",
    "        if init_name is not None:\n",
    "            self.init_weight(init_name)\n",
    "        \n",
    "    def init_weight(self, name):\n",
    "        if name == 'xavier_normal':\n",
    "            nn_init = nn.init.xavier_normal_\n",
    "        elif name == 'xavier_uniform':\n",
    "            nn_init = nn.init.xavier_uniform_\n",
    "        elif name == 'kaiming_normal':\n",
    "            nn_init = nn.init.kaiming_normal_\n",
    "        elif name == 'kaiming_uniform':\n",
    "            nn_init =  nn.init.kaiming_uniform_\n",
    "        else:\n",
    "            raise ValueError(f'unknown initialization function: {name}')\n",
    "    \n",
    "        for param in self.parameters():\n",
    "            if len(param.shape) > 1:\n",
    "                nn_init(param)\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.model(x)\n",
    "\n",
    "    def forward_test(self, x):\n",
    "        print(f\"{'input':<20}{str(x.shape):<40}\")\n",
    "        for name, module in self.model._modules.items():\n",
    "              x = module(x)\n",
    "              print(f\"{name:<20}{str(x.shape):<40}\")\n",
    "        return x              \n",
    "    \n",
    "    def model_size(self):\n",
    "        n_params = 0\n",
    "        for param in self.parameters():\n",
    "            n_params += param.numel()\n",
    "        return n_params"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2、Burgers方程"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "考虑一维Burgers方程：\n",
    "$$\n",
    "\\left\\{\n",
    "\\begin{array}{rl}\n",
    "u_t + uu_x - \\frac{0.01}\\pi u_{xx} = 0, & x \\in[-1, 1], ~~ t \\in [0, 1]\\\\\n",
    "u(0, x) = - \\sin(\\pi x), & \\\\\n",
    "u(t,-1) = u(t, 1) = 0.\n",
    "\\end{array}\n",
    "\\right.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1、问题描述"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Problem_Burgers(object):\n",
    "    \"\"\"Description of Burgers equation.\"\"\"\n",
    "    def __init__(self, domain=(0, 1, -1, 1)):\n",
    "        self.domain = domain\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f'{self.__doc__}' \n",
    "    \n",
    "    def f(self, x, verbose=None):\n",
    "        num_data, _ = x.shape\n",
    "        out = np.zeros((num_data, 1))\n",
    "        if verbose == 'tensor':\n",
    "            return torch.from_numpy(out).float()\n",
    "        return out\n",
    "    \n",
    "    def g_bc(self, x_bc, verbose=None):\n",
    "        num_data, _ = x_bc.shape\n",
    "        out = np.zeros((num_data, 1))\n",
    "        if verbose == 'tensor':\n",
    "            return torch.from_numpy(out).float()\n",
    "        return out\n",
    "    \n",
    "    def g_init(self, x_init, verbose=None):\n",
    "        out = - np.sin(np.pi * x_init[:, [1]])\n",
    "        if verbose == 'tensor':\n",
    "            return torch.from_numpy(out).float()\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2、数据集生成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Trainset_Burgers(object):\n",
    "    def __init__(self, problem, *args, **kwargs):\n",
    "        self.problem = problem\n",
    "        self.domain = problem.domain\n",
    "        self.args = args\n",
    "        self.method = kwargs['method']\n",
    "\n",
    "    def __call__(self, plot=False, verbose=None):\n",
    "        if self.method == 'uniform':\n",
    "            n_x, n_y = self.args[0], self.args[1]\n",
    "            x, x_bc, x_init = self._uniform_sample(n_x, n_y)\n",
    "        elif self.method == 'lhs':\n",
    "            n, n_bc = self.args[0], self.args[1]\n",
    "            x, x_bc, x_init = self._lhs_sample(n, n_bc)\n",
    "        f = self.problem.f(x)\n",
    "        g_bc = self.problem.g_bc(x_bc)\n",
    "        g_init = self.problem.g_init(x_init)\n",
    "\n",
    "        if plot:\n",
    "            fig = plt.figure()\n",
    "            ax = fig.add_subplot(111)\n",
    "            ax.scatter(x[:, 0], x[:, 1], facecolor='r', s=10)\n",
    "            ax.scatter(x_bc[:, 0], x_bc[:, 1], facecolor='b', s=10)\n",
    "            ax.scatter(x_init[:, 0], x_init[:, 1], facecolor='b', s=10)\n",
    "            ax.set_xlim(-0.01, 1.01)\n",
    "            ax.set_ylim(-1.01, 1.01)\n",
    "            plt.show()\n",
    "\n",
    "        if verbose == 'tensor':\n",
    "            f = torch.from_numpy(f).float()\n",
    "            g_bc = torch.from_numpy(g_bc).float()\n",
    "            g_init = torch.from_numpy(g_init).float()\n",
    "            x = torch.from_numpy(x).float()\n",
    "            x_bc = torch.from_numpy(x_bc).float()\n",
    "            x_init = torch.from_numpy(x_init).float()\n",
    "            return x, x_bc, x_init, f, g_bc, g_init\n",
    "        # (N, 2) & (N, 1)\n",
    "        return x, x_bc, x_init, f, g_bc, g_init\n",
    "\n",
    "    def _uniform_sample(self, n_x, n_y):\n",
    "        t_min, t_max, x_min, x_max = self.domain\n",
    "        t = np.linspace(t_min, t_max, n_x)\n",
    "        x = np.linspace(x_min, x_max, n_y)\n",
    "        t, x = np.meshgrid(t, x)  \n",
    "        xy = np.hstack((t.reshape(t.size, -1), x.reshape(x.size, -1)))\n",
    "\n",
    "        mask1 = (xy[:, 1] - x_min) * (x_max - xy[:, 1]) == 0\n",
    "        mask2 = (xy[:, 0] - t_min) == 0\n",
    "        mask3 = mask1 + mask2\n",
    "        x_bc = xy[mask1]\n",
    "        x_init = xy[mask2]\n",
    "        x = xy[np.logical_not(mask3)]\n",
    "\n",
    "        return x, x_bc, x_init\n",
    "\n",
    "    def _lhs_sample(self, n, n_bc):\n",
    "        t_min, t_max, x_min, x_max = self.domain\n",
    "\n",
    "        lb = np.array([t_min, x_min])\n",
    "        ub = np.array([t_max, x_max])\n",
    "        x = lb + (ub - lb) * lhs(2, n)\n",
    "\n",
    "        lb = np.array([t_min, x_min])\n",
    "        ub = np.array([t_max, x_min])\n",
    "        x_bc = lb + (ub - lb) * lhs(2, n_bc//3)\n",
    "\n",
    "        lb = np.array([t_min, x_max])\n",
    "        ub = np.array([t_max, x_max])\n",
    "        temp = lb + (ub - lb) * lhs(2, n_bc//3)\n",
    "        x_bc = np.vstack((x_bc, temp))\n",
    "\n",
    "        lb = np.array([t_min, x_min])\n",
    "        ub = np.array([t_min, x_max])\n",
    "        x_init = lb + (ub - lb) * lhs(2, n_bc//3)\n",
    "        return x, x_bc, x_init"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1482, 2) (80, 2) (40, 2) (1482, 1) (80, 1) (40, 1)\n"
     ]
    }
   ],
   "source": [
    "problem = Problem_Burgers()\n",
    "trainset = Trainset_Burgers(problem, 40, 40, method='uniform')\n",
    "# trainset = Trainset_Burgers(problem, 1000, 400, method='lhs')\n",
    "\n",
    "x, x_bc, x_init, f, g_bc, g_init = trainset(plot=True)\n",
    "print(x.shape, x_bc.shape, x_init.shape, f.shape, g_bc.shape, g_init.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Testset_Burgers(object):\n",
    "    \"\"\"Dataset on a square domain\"\"\"\n",
    "    def __init__(self, problem):\n",
    "        self.problem = problem\n",
    "        self.domain = problem.domain\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f'{self.__doc__}'\n",
    "        \n",
    "    def __call__(self, plot=False, verbose=None):\n",
    "        data = scipy.io.loadmat('burgers_shock.mat')\n",
    "        x = data['x'].squeeze()\n",
    "        t = data['t'].squeeze()\n",
    "        t, x = np.meshgrid(t,x)\n",
    "        X = np.hstack((t.reshape(t.size, -1), x.reshape(x.size, -1)))\n",
    "        u = data['usol']\n",
    "        \n",
    "        if plot == True:\n",
    "            fig = plt.figure()\n",
    "            ax = fig.add_subplot(121)\n",
    "            ax.scatter(X[:, 0], X[:, 1], facecolor='r', s=0.1)\n",
    "            ax.set_xlim(-0.01, 1.01)\n",
    "            ax.set_ylim(-1.01, 1.01)\n",
    "            \n",
    "            ax = fig.add_subplot(122, projection='3d')\n",
    "            ax.plot_surface(t, x, u, cmap=cm.coolwarm)\n",
    "            plt.show() \n",
    "            \n",
    "        if verbose == 'tensor':\n",
    "            X = torch.from_numpy(X).float()\n",
    "            \n",
    "        return X, t, x, u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "testset = Testset_Burgers(problem)\n",
    "X, x, y, u = testset(plot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3、网络结构"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grad(outputs, inputs):\n",
    "    \"\"\" compute the derivative of outputs associated with inputs\n",
    "    \n",
    "    Params\n",
    "    ======\n",
    "    outputs: (N, 1) tensor\n",
    "    inputs: (N, D) tensor\n",
    "    \"\"\"\n",
    "    return torch.autograd.grad(outputs, inputs,\n",
    "                               grad_outputs=torch.ones_like(outputs),\n",
    "                               create_graph=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PINN(DNN):\n",
    "    \"\"\"Physics Constrained Neural Networks\n",
    "    \"\"\"\n",
    "    def __init__(self, dim_in, dim_out, dim_hidden, hidden_layers, \n",
    "                 act_name='tanh', init_name='xavier_normal'):\n",
    "        super().__init__(dim_in, dim_out, dim_hidden, hidden_layers, \n",
    "                         act_name=act_name, init_name=init_name)\n",
    "        \n",
    "    def forward(self, problem, x, x_bc=None, x_init=None):\n",
    "        x.requires_grad_(True)\n",
    "        u = super().forward(x)\n",
    "\n",
    "        grad_u = grad(u, x)[0]     \n",
    "        u_x = grad_u[:, [1]]\n",
    "        u_t = grad_u[:, [0]]\n",
    "        u_xx = grad(u_x, x)[0][:, [1]]\n",
    "        x.detach_()\n",
    "        f = u_t + u * u_x - (0.01 / np.pi) * u_xx\n",
    "        if x_bc is not None:\n",
    "            g_bc = super().forward(x_bc)\n",
    "            g_init = super().forward(x_init)\n",
    "            return u, f, g_bc, g_init\n",
    "        return u, f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "problem = Problem_Burgers()\n",
    "trainset = Trainset_Burgers(problem, 1000, 400, method='lhs')\n",
    "x, x_bc, x_init, f, g_bc, g_init = trainset(plot=True, verbose='tensor')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "811\n",
      "torch.Size([1000, 1]) torch.Size([1000, 1]) torch.Size([266, 1]) torch.Size([133, 1])\n"
     ]
    }
   ],
   "source": [
    "model = PINN(2, 1, 10, 8)\n",
    "print(model.model_size())\n",
    "\n",
    "u_pred, f_pred, g_bc, g_init = model(problem, x, x_bc, x_init)\n",
    "print(u_pred.shape, f_pred.shape, g_bc.shape, g_init.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4、Options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Options_Burgers(object):\n",
    "    def __init__(self):\n",
    "        parser = argparse.ArgumentParser()\n",
    "        parser.add_argument('--no_cuda', action='store_true', default=False, help='disable CUDA or not')\n",
    "        parser.add_argument('--dim_hidden', type=int, default=10, help='neurons in hidden layers')\n",
    "        parser.add_argument('--hidden_layers', type=int, default=4, help='number of hidden layers')\n",
    "        parser.add_argument('--res_blocks', type=int, default=4, help='number of residual blocks')\n",
    "        parser.add_argument('--lam', type=float, default=1, help='weight in loss function')\n",
    "        parser.add_argument('--lr', type=float, default=1e-3, help='initial learning rate')\n",
    "        parser.add_argument('--epochs_Adam', type=int, default=5000, help='epochs for Adam optimizer')\n",
    "        parser.add_argument('--epochs_LBFGS', type=int, default=200, help='epochs for LBFGS optimizer')\n",
    "        parser.add_argument('--step_size', type=int, default=2000, help='step size in lr_scheduler for Adam optimizer')\n",
    "        parser.add_argument('--gamma', type=float, default=0.7, help='gamma in lr_scheduler for Adam optimizer')\n",
    "        parser.add_argument('--resume', type=bool, default=False, help='resume or not')\n",
    "        parser.add_argument('--sample_method', type=str, default='lhs', help='sample method')\n",
    "        parser.add_argument('--n_x', type=int, default=100, help='sample points in x-direction for uniform sample')\n",
    "        parser.add_argument('--n_y', type=int, default=100, help='sample points in y-direction for uniform sample')\n",
    "        parser.add_argument('--n', type=int, default=10000, help='sample points in domain for lhs sample')\n",
    "        parser.add_argument('--n_bc', type=int, default=400, help='sample points on the boundary for lhs sample')\n",
    "        \n",
    "        self.parser = parser\n",
    "        \n",
    "    def parse(self):\n",
    "        arg = self.parser.parse_args(args=[])\n",
    "        arg.cuda = not arg.no_cuda and torch.cuda.is_available()\n",
    "        arg.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "        return arg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5、训练过程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_model(state, is_best=None, save_dir=None):\n",
    "    last_model = os.path.join(save_dir, 'last_model.pth.tar')\n",
    "    torch.save(state, last_model)\n",
    "    if is_best:\n",
    "        best_model = os.path.join(save_dir, 'best_model.pth.tar')\n",
    "        shutil.copyfile(last_model, best_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Trainer_Burgers(object):\n",
    "    def __init__(self, args):\n",
    "        self.device  = args.device\n",
    "        self.problem = args.problem\n",
    "        \n",
    "        self.lam = args.lam\n",
    "        self.criterion = nn.MSELoss()\n",
    "        \n",
    "        self.model = args.model\n",
    "        self.model_name = self.model.__class__.__name__\n",
    "        self.model_path = self._model_path()\n",
    "        \n",
    "        self.epochs_Adam = args.epochs_Adam\n",
    "        self.epochs_LBFGS = args.epochs_LBFGS\n",
    "        self.optimizer_Adam = optim.Adam(self.model.parameters(), lr=args.lr)\n",
    "        self.optimizer_LBFGS = optim.LBFGS(self.model.parameters(), \n",
    "                                           max_iter=20, \n",
    "                                           tolerance_grad=1.e-8,\n",
    "                                           tolerance_change=1.e-12)\n",
    "        self.lr_scheduler = StepLR(self.optimizer_Adam, \n",
    "                                   step_size=args.step_size, \n",
    "                                   gamma=args.gamma)\n",
    "\n",
    "        self.model.to(self.device)\n",
    "        self.model.zero_grad()\n",
    "        \n",
    "        self.x,     self.x_bc,     self.x_init    , self.f    , self.g_bc    , self.g_init     = args.trainset(verbose='tensor')\n",
    "        self.x_val, self.x_bc_val, self.x_init_val, self.f_val, self.g_bc_val, self.g_init_val = args.validset(verbose='tensor')\n",
    "        \n",
    "        if self.device == torch.device(type='cuda'):\n",
    "            for item in [self.x, self.x_bc, self.x_init, self.f, self.g_bc, self.g_init, \n",
    "                         self.x_val, self.x_bc_val, self.x_init_val, self.f_val, self.g_bc_val, self.g_init_val]:\n",
    "                item = item.to(self.device)\n",
    "        \n",
    "    def _model_path(self):\n",
    "        \"\"\"Path to save the model\"\"\"\n",
    "        if not os.path.exists('checkpoints'):\n",
    "            os.mkdir('checkpoints')\n",
    "\n",
    "        path = os.path.join('checkpoints', self.model_name)\n",
    "        if not os.path.exists(path):\n",
    "            os.mkdir(path)\n",
    "        return path\n",
    "    \n",
    "    def train(self):\n",
    "        best_loss = 1.e10\n",
    "        \n",
    "        for epoch in range(self.epochs_Adam):\n",
    "            loss, loss1, loss2 = self.train_Adam()\n",
    "            if (epoch + 1) % 100 == 0:\n",
    "                self.infos_Adam(epoch+1, loss, loss1, loss2)\n",
    "                \n",
    "                valid_loss = self.validate(epoch)\n",
    "                is_best = valid_loss < best_loss\n",
    "                best_loss = valid_loss if is_best else best_loss                \n",
    "                state = {\n",
    "                    'epoch': epoch,\n",
    "                    'state_dict': self.model.state_dict(),\n",
    "                    'best_loss': best_loss\n",
    "                }\n",
    "                save_model(state, is_best, save_dir=self.model_path)\n",
    "                \n",
    "            \n",
    "        for epoch in range(self.epochs_Adam, self.epochs_Adam + self.epochs_LBFGS):\n",
    "            loss, loss1, loss2 = self.train_LBFGS()\n",
    "            if (epoch + 1) % 20 == 0:\n",
    "                self.infos_LBFGS(epoch+1, loss, loss1, loss2)\n",
    "                \n",
    "                valid_loss = self.validate(epoch)\n",
    "                is_best = valid_loss < best_loss\n",
    "                best_loss = valid_loss if is_best else best_loss                \n",
    "                state = {\n",
    "                    'epoch': epoch,\n",
    "                    'state_dict': self.model.state_dict(),\n",
    "                    'best_loss': best_loss\n",
    "                }\n",
    "                save_model(state, is_best, save_dir=self.model_path)\n",
    "            \n",
    "    def train_Adam(self):\n",
    "        self.optimizer_Adam.zero_grad()\n",
    "\n",
    "        _, f_pred, g_bc, g_init = self.model(self.problem, self.x, self.x_bc, self.x_init)\n",
    "        loss1 = self.criterion(f_pred, self.f)\n",
    "        loss2 = self.criterion(g_bc, self.g_bc) + self.criterion(g_init, self.g_init)\n",
    "        loss = loss1 + self.lam * loss2\n",
    "\n",
    "        loss.backward()\n",
    "        self.optimizer_Adam.step()\n",
    "        self.lr_scheduler.step()\n",
    "\n",
    "        return loss.item(), loss1.item(), loss2.item()\n",
    "\n",
    "    def infos_Adam(self, epoch, loss, loss1, loss2):\n",
    "        infos = 'Adam  ' + \\\n",
    "            f'Epoch #{epoch:5d}/{self.epochs_Adam+self.epochs_LBFGS} ' + \\\n",
    "            f'Loss: {loss:.4e} = {loss1:.4e} + {self.lam} * {loss2:.4e} ' + \\\n",
    "            f'lr: {self.lr_scheduler.get_lr()[0]:.2e} '\n",
    "        print(infos)\n",
    "        \n",
    "    def train_LBFGS(self):\n",
    "\n",
    "        # only used to compute loss_int and loss_bc1 for monitoring\n",
    "        _, f_pred, g_bc, g_init = self.model(self.problem, self.x, self.x_bc, self.x_init)\n",
    "        loss1 = self.criterion(f_pred, self.f)\n",
    "        loss2 = self.criterion(g_bc, self.g_bc) + self.criterion(g_init, self.g_init)\n",
    "\n",
    "        def closure():\n",
    "            if torch.is_grad_enabled():\n",
    "                self.optimizer_LBFGS.zero_grad()\n",
    "            _, f_pred, g_bc, g_init = self.model(self.problem, self.x, self.x_bc, self.x_init)\n",
    "            loss1 = self.criterion(f_pred, self.f)\n",
    "            loss2 = self.criterion(g_bc, self.g_bc) + self.criterion(g_init, self.g_init)\n",
    "            loss = loss1 + self.lam * loss2\n",
    "            if loss.requires_grad:\n",
    "                loss.backward()\n",
    "            return loss\n",
    "\n",
    "        self.optimizer_LBFGS.step(closure)\n",
    "        loss = closure()\n",
    "\n",
    "        return loss.item(), loss1.item(), loss2.item()\n",
    "        \n",
    "    def infos_LBFGS(self, epoch, loss, loss1, loss2):\n",
    "        infos = 'LBFGS ' + \\\n",
    "            f'Epoch #{epoch:5d}/{self.epochs_Adam+self.epochs_LBFGS} ' + \\\n",
    "            f'Loss: {loss:.2e} = {loss1:.2e} + {self.lam:d} * {loss2:.2e} '\n",
    "        print(infos)\n",
    "\n",
    "    def validate(self, epoch):\n",
    "        self.model.eval()\n",
    "        _, f_pred, g_bc, g_init = self.model(self.problem, self.x_val, self.x_bc_val, self.x_init_val)\n",
    "        loss1 = self.criterion(f_pred, self.f_val)\n",
    "        loss2 = self.criterion(g_bc, self.g_bc_val) + self.criterion(g_init, self.g_init_val)\n",
    "        loss = loss1 + self.lam * loss2\n",
    "        \n",
    "        infos = 'Valid ' + \\\n",
    "            f'Epoch #{epoch+1:5d}/{self.epochs_Adam+self.epochs_LBFGS} ' + \\\n",
    "            f'Loss: {loss:.4e} '\n",
    "        print(infos)\n",
    "        self.model.train()\n",
    "        return loss.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adam  Epoch #  100/5200 Loss: 3.7859e-01 = 1.8818e-02 + 1 * 3.5977e-01 lr: 1.00e-03 \n",
      "Valid Epoch #  100/5200 Loss: 3.7615e-01 \n",
      "Adam  Epoch #  200/5200 Loss: 2.0413e-01 = 3.0363e-02 + 1 * 1.7376e-01 lr: 1.00e-03 \n",
      "Valid Epoch #  200/5200 Loss: 2.0099e-01 \n",
      "Adam  Epoch #  300/5200 Loss: 1.5532e-01 = 6.2339e-02 + 1 * 9.2985e-02 lr: 1.00e-03 \n",
      "Valid Epoch #  300/5200 Loss: 1.5467e-01 \n",
      "Adam  Epoch #  400/5200 Loss: 1.4812e-01 = 5.9486e-02 + 1 * 8.8635e-02 lr: 1.00e-03 \n",
      "Valid Epoch #  400/5200 Loss: 1.4754e-01 \n",
      "Adam  Epoch #  500/5200 Loss: 1.4161e-01 = 5.7407e-02 + 1 * 8.4207e-02 lr: 1.00e-03 \n",
      "Valid Epoch #  500/5200 Loss: 1.4108e-01 \n",
      "Adam  Epoch #  600/5200 Loss: 1.3737e-01 = 5.5661e-02 + 1 * 8.1705e-02 lr: 1.00e-03 \n",
      "Valid Epoch #  600/5200 Loss: 1.3680e-01 \n",
      "Adam  Epoch #  700/5200 Loss: 1.3224e-01 = 5.2919e-02 + 1 * 7.9325e-02 lr: 1.00e-03 \n",
      "Valid Epoch #  700/5200 Loss: 1.3162e-01 \n",
      "Adam  Epoch #  800/5200 Loss: 1.2551e-01 = 5.0086e-02 + 1 * 7.5420e-02 lr: 1.00e-03 \n",
      "Valid Epoch #  800/5200 Loss: 1.2476e-01 \n",
      "Adam  Epoch #  900/5200 Loss: 1.1387e-01 = 4.5951e-02 + 1 * 6.7920e-02 lr: 1.00e-03 \n",
      "Valid Epoch #  900/5200 Loss: 1.1297e-01 \n",
      "Adam  Epoch # 1000/5200 Loss: 1.0103e-01 = 4.1939e-02 + 1 * 5.9091e-02 lr: 1.00e-03 \n",
      "Valid Epoch # 1000/5200 Loss: 1.0033e-01 \n",
      "Adam  Epoch # 1100/5200 Loss: 9.3110e-02 = 4.0053e-02 + 1 * 5.3057e-02 lr: 1.00e-03 \n",
      "Valid Epoch # 1100/5200 Loss: 9.3196e-02 \n",
      "Adam  Epoch # 1200/5200 Loss: 8.9107e-02 = 3.8789e-02 + 1 * 5.0318e-02 lr: 1.00e-03 \n",
      "Valid Epoch # 1200/5200 Loss: 8.9772e-02 \n",
      "Adam  Epoch # 1300/5200 Loss: 8.5260e-02 = 3.7077e-02 + 1 * 4.8183e-02 lr: 1.00e-03 \n",
      "Valid Epoch # 1300/5200 Loss: 8.6178e-02 \n",
      "Adam  Epoch # 1400/5200 Loss: 8.0593e-02 = 3.4717e-02 + 1 * 4.5875e-02 lr: 1.00e-03 \n",
      "Valid Epoch # 1400/5200 Loss: 8.1429e-02 \n",
      "Adam  Epoch # 1500/5200 Loss: 7.3960e-02 = 3.1182e-02 + 1 * 4.2778e-02 lr: 1.00e-03 \n",
      "Valid Epoch # 1500/5200 Loss: 7.4187e-02 \n",
      "Adam  Epoch # 1600/5200 Loss: 6.6076e-02 = 2.7857e-02 + 1 * 3.8219e-02 lr: 1.00e-03 \n",
      "Valid Epoch # 1600/5200 Loss: 6.6078e-02 \n",
      "Adam  Epoch # 1700/5200 Loss: 6.0388e-02 = 2.6059e-02 + 1 * 3.4329e-02 lr: 1.00e-03 \n",
      "Valid Epoch # 1700/5200 Loss: 6.0770e-02 \n",
      "Adam  Epoch # 1800/5200 Loss: 5.6529e-02 = 2.4990e-02 + 1 * 3.1539e-02 lr: 1.00e-03 \n",
      "Valid Epoch # 1800/5200 Loss: 5.7988e-02 \n",
      "Adam  Epoch # 1900/5200 Loss: 5.3780e-02 = 2.4039e-02 + 1 * 2.9742e-02 lr: 1.00e-03 \n",
      "Valid Epoch # 1900/5200 Loss: 5.6037e-02 \n",
      "Adam  Epoch # 2000/5200 Loss: 5.1695e-02 = 2.3421e-02 + 1 * 2.8274e-02 lr: 4.90e-04 \n",
      "Valid Epoch # 2000/5200 Loss: 5.4923e-02 \n",
      "Adam  Epoch # 2100/5200 Loss: 5.0390e-02 = 2.3002e-02 + 1 * 2.7389e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 2100/5200 Loss: 5.4487e-02 \n",
      "Adam  Epoch # 2200/5200 Loss: 4.9103e-02 = 2.2628e-02 + 1 * 2.6475e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 2200/5200 Loss: 5.0295e-02 \n",
      "Adam  Epoch # 2300/5200 Loss: 4.7881e-02 = 2.2103e-02 + 1 * 2.5778e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 2300/5200 Loss: 4.8815e-02 \n",
      "Adam  Epoch # 2400/5200 Loss: 4.6842e-02 = 2.1652e-02 + 1 * 2.5190e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 2400/5200 Loss: 4.8129e-02 \n",
      "Adam  Epoch # 2500/5200 Loss: 4.5797e-02 = 2.1280e-02 + 1 * 2.4517e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 2500/5200 Loss: 4.6932e-02 \n",
      "Adam  Epoch # 2600/5200 Loss: 4.4735e-02 = 2.0883e-02 + 1 * 2.3852e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 2600/5200 Loss: 4.6484e-02 \n",
      "Adam  Epoch # 2700/5200 Loss: 4.3484e-02 = 2.0431e-02 + 1 * 2.3053e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 2700/5200 Loss: 4.5460e-02 \n",
      "Adam  Epoch # 2800/5200 Loss: 4.1895e-02 = 1.9935e-02 + 1 * 2.1960e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 2800/5200 Loss: 4.3913e-02 \n",
      "Adam  Epoch # 2900/5200 Loss: 4.0309e-02 = 1.9332e-02 + 1 * 2.0978e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 2900/5200 Loss: 4.2462e-02 \n",
      "Adam  Epoch # 3000/5200 Loss: 3.8939e-02 = 1.9107e-02 + 1 * 1.9831e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 3000/5200 Loss: 4.0700e-02 \n",
      "Adam  Epoch # 3100/5200 Loss: 3.7175e-02 = 1.8144e-02 + 1 * 1.9031e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 3100/5200 Loss: 3.9822e-02 \n",
      "Adam  Epoch # 3200/5200 Loss: 3.5511e-02 = 1.7545e-02 + 1 * 1.7967e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 3200/5200 Loss: 3.8292e-02 \n",
      "Adam  Epoch # 3300/5200 Loss: 3.3691e-02 = 1.6847e-02 + 1 * 1.6844e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 3300/5200 Loss: 3.6663e-02 \n",
      "Adam  Epoch # 3400/5200 Loss: 3.1958e-02 = 1.6148e-02 + 1 * 1.5809e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 3400/5200 Loss: 3.4989e-02 \n",
      "Adam  Epoch # 3500/5200 Loss: 3.1832e-02 = 1.7223e-02 + 1 * 1.4609e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 3500/5200 Loss: 3.0193e-02 \n",
      "Adam  Epoch # 3600/5200 Loss: 2.8122e-02 = 1.4677e-02 + 1 * 1.3446e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 3600/5200 Loss: 3.0958e-02 \n",
      "Adam  Epoch # 3700/5200 Loss: 2.6001e-02 = 1.3785e-02 + 1 * 1.2215e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 3700/5200 Loss: 2.9174e-02 \n",
      "Adam  Epoch # 3800/5200 Loss: 2.4346e-02 = 1.3050e-02 + 1 * 1.1296e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 3800/5200 Loss: 2.6833e-02 \n",
      "Adam  Epoch # 3900/5200 Loss: 2.3087e-02 = 1.2434e-02 + 1 * 1.0653e-02 lr: 7.00e-04 \n",
      "Valid Epoch # 3900/5200 Loss: 2.5562e-02 \n",
      "Adam  Epoch # 4000/5200 Loss: 2.1979e-02 = 1.1937e-02 + 1 * 1.0042e-02 lr: 3.43e-04 \n",
      "Valid Epoch # 4000/5200 Loss: 2.3776e-02 \n",
      "Adam  Epoch # 4100/5200 Loss: 2.1214e-02 = 1.1562e-02 + 1 * 9.6517e-03 lr: 4.90e-04 \n",
      "Valid Epoch # 4100/5200 Loss: 2.3239e-02 \n",
      "Adam  Epoch # 4200/5200 Loss: 2.0464e-02 = 1.1220e-02 + 1 * 9.2437e-03 lr: 4.90e-04 \n",
      "Valid Epoch # 4200/5200 Loss: 2.2305e-02 \n",
      "Adam  Epoch # 4300/5200 Loss: 1.9694e-02 = 1.0872e-02 + 1 * 8.8211e-03 lr: 4.90e-04 \n",
      "Valid Epoch # 4300/5200 Loss: 2.1376e-02 \n",
      "Adam  Epoch # 4400/5200 Loss: 1.9753e-02 = 1.1262e-02 + 1 * 8.4907e-03 lr: 4.90e-04 \n",
      "Valid Epoch # 4400/5200 Loss: 2.0786e-02 \n",
      "Adam  Epoch # 4500/5200 Loss: 1.8154e-02 = 1.0169e-02 + 1 * 7.9857e-03 lr: 4.90e-04 \n",
      "Valid Epoch # 4500/5200 Loss: 1.9534e-02 \n",
      "Adam  Epoch # 4600/5200 Loss: 1.8205e-02 = 1.0684e-02 + 1 * 7.5211e-03 lr: 4.90e-04 \n",
      "Valid Epoch # 4600/5200 Loss: 1.9101e-02 \n",
      "Adam  Epoch # 4700/5200 Loss: 1.6703e-02 = 9.4883e-03 + 1 * 7.2151e-03 lr: 4.90e-04 \n",
      "Valid Epoch # 4700/5200 Loss: 1.7673e-02 \n",
      "Adam  Epoch # 4800/5200 Loss: 1.6355e-02 = 9.4858e-03 + 1 * 6.8696e-03 lr: 4.90e-04 \n",
      "Valid Epoch # 4800/5200 Loss: 1.6678e-02 \n",
      "Adam  Epoch # 4900/5200 Loss: 1.5434e-02 = 8.8663e-03 + 1 * 6.5680e-03 lr: 4.90e-04 \n",
      "Valid Epoch # 4900/5200 Loss: 1.6050e-02 \n",
      "Adam  Epoch # 5000/5200 Loss: 1.5006e-02 = 8.6517e-03 + 1 * 6.3539e-03 lr: 4.90e-04 \n",
      "Valid Epoch # 5000/5200 Loss: 1.6190e-02 \n",
      "LBFGS Epoch # 5020/5200 Loss: 2.82e-03 = 2.08e-03 + 1 * 8.64e-04 \n",
      "Valid Epoch # 5020/5200 Loss: 2.8619e-03 \n",
      "LBFGS Epoch # 5040/5200 Loss: 4.99e-01 = 0.00e+00 + 1 * 4.99e-01 \n",
      "Valid Epoch # 5040/5200 Loss: 4.9500e-01 \n",
      "LBFGS Epoch # 5060/5200 Loss: 4.99e-01 = 0.00e+00 + 1 * 4.99e-01 \n",
      "Valid Epoch # 5060/5200 Loss: 4.9500e-01 \n",
      "LBFGS Epoch # 5080/5200 Loss: 4.99e-01 = 0.00e+00 + 1 * 4.99e-01 \n",
      "Valid Epoch # 5080/5200 Loss: 4.9500e-01 \n",
      "LBFGS Epoch # 5100/5200 Loss: 4.99e-01 = 0.00e+00 + 1 * 4.99e-01 \n",
      "Valid Epoch # 5100/5200 Loss: 4.9500e-01 \n",
      "LBFGS Epoch # 5120/5200 Loss: 4.99e-01 = 0.00e+00 + 1 * 4.99e-01 \n",
      "Valid Epoch # 5120/5200 Loss: 4.9500e-01 \n",
      "LBFGS Epoch # 5140/5200 Loss: 4.99e-01 = 0.00e+00 + 1 * 4.99e-01 \n",
      "Valid Epoch # 5140/5200 Loss: 4.9500e-01 \n",
      "LBFGS Epoch # 5160/5200 Loss: 4.99e-01 = 0.00e+00 + 1 * 4.99e-01 \n",
      "Valid Epoch # 5160/5200 Loss: 4.9500e-01 \n",
      "LBFGS Epoch # 5180/5200 Loss: 4.99e-01 = 0.00e+00 + 1 * 4.99e-01 \n",
      "Valid Epoch # 5180/5200 Loss: 4.9500e-01 \n",
      "LBFGS Epoch # 5200/5200 Loss: 4.99e-01 = 0.00e+00 + 1 * 4.99e-01 \n",
      "Valid Epoch # 5200/5200 Loss: 4.9500e-01 \n"
     ]
    }
   ],
   "source": [
    "# 使用Trainer_Burgers进行训练\n",
    "args = Options_Burgers().parse()\n",
    "args.problem = Problem_Burgers()\n",
    "args.model = PINN(dim_in=2,\n",
    "                  dim_out=1,\n",
    "                  dim_hidden=args.dim_hidden,\n",
    "                  hidden_layers=args.hidden_layers)\n",
    "\n",
    "# args.model = ResPINN(2, 1, dim_hidden=args.dim_hidden, res_blocks=args.res_blocks)\n",
    "if args.sample_method == 'uniform':\n",
    "    args.trainset = Trainset_Burgers(args.problem, args.n_x, args.n_y, method='uniform')\n",
    "elif args.sample_method == 'lhs':\n",
    "    args.trainset = Trainset_Burgers(args.problem, args.n, args.n_bc, method='lhs')\n",
    "\n",
    "args.validset = Trainset_Burgers(args.problem, 100, 100, method='uniform')\n",
    "    \n",
    "trainer = Trainer_Burgers(args)\n",
    "trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.6、测试过程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Tester_Burgers(object):\n",
    "    def __init__(self, args):\n",
    "        self.device  = args.device\n",
    "        self.problem = args.problem\n",
    "        self.criterion = nn.MSELoss()\n",
    "        self.model = args.model\n",
    "        model_name = self.model.__class__.__name__\n",
    "        model_path = os.path.join('checkpoints',\n",
    "                                  model_name,\n",
    "                                  'best_model.pth.tar')\n",
    "        best_model = torch.load(model_path)\n",
    "        self.model.load_state_dict(best_model['state_dict'])        \n",
    "        self.model.to(self.device)\n",
    "        self.X, self.t, self.x, self.u = args.testset(verbose='tensor')\n",
    "        if self.device == torch.device(type='cuda'):\n",
    "            self.X = self.X.to(self.device)\n",
    "    \n",
    "    def predict(self):\n",
    "        self.model.eval()\n",
    "        u_pred, _ = self.model(self.problem, self.X)\n",
    "        u_pred = u_pred.detach().cpu().numpy()\n",
    "        u_pred = u_pred.reshape(self.x.shape)\n",
    "        \n",
    "        fig = plt.figure()\n",
    "        ax = fig.add_subplot(131, projection='3d')\n",
    "        ax.plot_surface(self.t, self.x, self.u, cmap=cm.coolwarm)\n",
    "        ax = fig.add_subplot(132, projection='3d')\n",
    "        ax.plot_surface(self.t, self.x, u_pred, cmap=cm.coolwarm)\n",
    "        ax = fig.add_subplot(133, projection='3d')\n",
    "        ax.plot_surface(self.t, self.x, np.abs(u_pred-self.u), cmap=cm.coolwarm)\n",
    "        ax.set_xlim(-0.01, 1.01)\n",
    "        ax.set_ylim(-1.01, 1.01)\n",
    "\n",
    "    def plot(self):\n",
    "        self.model.eval()\n",
    "        u_pred, _ = self.model(self.problem, self.X)\n",
    "        u_pred = u_pred.detach().cpu().numpy()\n",
    "        u_pred = u_pred.reshape(self.x.shape)\n",
    "        fig, ax = plt.subplots(figsize=(10, 9))\n",
    "        ax.axis('off')  \n",
    "        \n",
    "        ####### Row 0: u(t,x) ################## \n",
    "        gs0 = gridspec.GridSpec(1, 2)\n",
    "        gs0.update(top=1-0.06, bottom=1-1.0/3.0+0.06, left=0.15, right=0.85, wspace=0)\n",
    "        ax = plt.subplot(gs0[:, :])\n",
    "\n",
    "        h = ax.imshow(u_pred, interpolation='nearest', cmap='rainbow', \n",
    "                      extent=[self.t.min(), self.t.max(), self.x.min(), self.x.max()], \n",
    "                      origin='lower', aspect='auto')\n",
    "        divider = make_axes_locatable(ax)\n",
    "        cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n",
    "        fig.colorbar(h, cax=cax)\n",
    "\n",
    "        line = np.linspace(self.x.min(), self.x.max(), 2)[:, None]\n",
    "        ax.plot(self.t[:, 25]*np.ones((2,1)), line, 'w-', linewidth = 1)\n",
    "        ax.plot(self.t[:, 50]*np.ones((2,1)), line, 'w-', linewidth = 1)\n",
    "        ax.plot(self.t[:, 75]*np.ones((2,1)), line, 'w-', linewidth = 1)\n",
    "\n",
    "        ax.set_xlabel('$t$')\n",
    "        ax.set_ylabel('$x$')\n",
    "        ax.set_title('$u(t,x)$', fontsize = 10)\n",
    "        \n",
    "        ####### Row 1: u(t,x) slices ##################    \n",
    "        gs1 = gridspec.GridSpec(1, 3)\n",
    "        gs1.update(top=1-1.0/3.0-0.1, bottom=1.0-2.0/3.0, left=0.1, right=0.9, wspace=0.5)\n",
    "\n",
    "        ax = plt.subplot(gs1[0, 0])\n",
    "        ax.plot(self.x[:, 0],self.u[:, 25], 'b-', linewidth = 2, label = 'Exact')       \n",
    "        ax.plot(self.x[:, 0],u_pred[:, 25], 'r--', linewidth = 2, label = 'Prediction')\n",
    "        ax.set_xlabel('$x$')\n",
    "        ax.set_ylabel('$u(t,x)$')    \n",
    "        ax.set_title('$t = 0.25$', fontsize = 10)\n",
    "        ax.axis('square')\n",
    "        ax.set_xlim([-1.1,1.1])\n",
    "        ax.set_ylim([-1.1,1.1])\n",
    "\n",
    "        ax = plt.subplot(gs1[0, 1])\n",
    "        ax.plot(self.x[:, 0],self.u[:, 50], 'b-', linewidth = 2, label = 'Exact')       \n",
    "        ax.plot(self.x[:, 0],u_pred[:, 50], 'r--', linewidth = 2, label = 'Prediction')\n",
    "        ax.set_xlabel('$x$')\n",
    "        ax.set_ylabel('$u(t,x)$')\n",
    "        ax.axis('square')\n",
    "        ax.set_xlim([-1.1,1.1])\n",
    "        ax.set_ylim([-1.1,1.1])\n",
    "        ax.set_title('$t = 0.50$', fontsize = 10)\n",
    "        ax.legend(loc='upper center', bbox_to_anchor=(0.5, -0.35), ncol=5, frameon=False)\n",
    "\n",
    "        ax = plt.subplot(gs1[0, 2])\n",
    "        ax.plot(self.x[:, 0],u_pred[:, 75], 'b-', linewidth = 2, label = 'Exact')       \n",
    "        ax.plot(self.x[:, 0],u_pred[:, 75], 'r--', linewidth = 2, label = 'Prediction')\n",
    "        ax.set_xlabel('$x$')\n",
    "        ax.set_ylabel('$u(t,x)$')\n",
    "        ax.axis('square')\n",
    "        ax.set_xlim([-1.1,1.1])\n",
    "        ax.set_ylim([-1.1,1.1])    \n",
    "        ax.set_title('$t = 0.75$', fontsize = 10)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9WYxlWVrv91vDHs8Yc0TOY1VWVdeYNCCbqytzuUZqqXnAEvSL7ftwn4yELT8gIRC227KaF78gbD9wjQBLwDXXxt33QnPpBhromc7smivnOSojM+Y40x7X8sOOExWZGXOciIyoOn8plZlx4uyzz/r2+ob/NyxhraWPPvroo4/9gXzeN9BHH3308VlCX+n20Ucffewj+kq3jz766GMf0Ve6ffTRRx/7iL7S7aOPPvrYR+hNXu+XNhwciB5eqy/Xg4NeyhX6sj0oWFeufU+3jz766GMf0Ve6ffTRRx/7iL7S7aOPPvrYR/SVbh999NHHPqKvdPvoo48+9hF9pdtHH330sY/oK90++uijj31EX+n20Ucffewj+kq3jz766GMf0Ve6ffTRRx/7iL7S7aOPPvrYR/SVbh999NHHPqKvdPvoo48+9hGHWukmSUKr1SLP8+d9K330EGma0mg0yLLsed9KHz2EMYZms0mapnyWz2Y8tErXGEOapsRxTKPRoNPpYIx53rfVxy5hrSXLMvI8p9Fo0G63+3L9FMBay9TUFGma8v7777O0tPSZdZYOpdK11pKmKQBKKaSU3L59m/v37xPH8Wfaih52ZFmGtRYpJUoppqamuHbtGlEU9eV6iJHnOVevXkUIwdLSEmmasrS09Jk0qodS6TabTR48eIAQxZxgIQRpmpLnOZ1Oh0ajQZIk/U16yJBlGdevX39Crt2IJooilpaW+kb1EKLrJHXlCoWzpJQiSRKWlpY+U0b10Clday3tdpv5+fknft4VqFJq5XdarVafFzwk6G7Mx48fP/Hz1XIVQqwY1c86L3hYYK0lSRKAJ5SutRYhxEqk+lkyqodO6T5tMdeClBIpJVmW0Ww2abVan7kQ5rAhy7InZLTWxutuUmstrVarn0Q9BMjzHGPMyp7tKtvV6MoV+EwY1UOldPM8J89zhBCbCmS1Fe3yR/1k28GEMYYsyzY1pl2sNqqfVV7wMKCbFBVCbEm2XR7fWrviLH0ajepmB1MeGKzmhVZzfpthtXcUxzFJkuD7Pq7rbnmT97F3WJ0UlVKuGNPNZLNarkmSrMjV87y+XA8IVidFYWv7FYrnQAhBlmU0Gg1c18X3/ZXrHHYcmm/RFeBGgtvI++1u0j4veLDwdPi5FrYi188aL3jQsV700pXLdiLVT1uy7VAo3acFuBa9sFUruhYv2E+2PR88HX6uFcFsV659o/r8sTp6WUt+24lEPo1G9cAr3c0EuFOs5gX7RfjPB1uJXraL1Ub108wLHmRsJXrZLlYn29rtNs1mc+X5OWw48Ep3PQH2YrG7gny6XrCvfPce202ebRfdpEw/2ba/WCv30sVWEuCbQUqJ1hpjDI1G41Aa1QOdSFsv+9nrjbraO4qiiDiO+8m2PcRGG7OX6Cfb9hdbjUp7pXwPa7LtQN/hdsPP3QryaV7w4cOHh54/OojYbvjZK7l2ecGpqSlarVZfrj2GMWalpHMt7JWzJKUkjmPu379Po9E48HI9sJ7uRuHnbhJpW0FXmNevX1+xoL7vo/WBXa5Dg7VaQjfCXsh1cnJypW08CAK01n3Pd5fYavSyFwpRCIHWmqmpKZRSGGMOdKR6ID3d/Qo/t4J+sq13WK8l9HmgWxPcT7b1BnuRFN0urLWHItl2IJVutyV0uwLs9eKunnb1WR3O0UvsRVZ7J+gqh36yrTfYalJ0o5LPXmG1XA9qsu3AxctbEeBe0wvrfWY/2bZzbLcl9On37hX6ybbdYbslnfvlrKyu/T5oybYD5enuVU3uTrHR0JV+Ef72sNPwcy+eg42GrnyaivD3AwcleoHN5XpQItUDpXS3KsC9DE/W+qz1ft4vwt8a9romt5d4ugi/b1TXx3ZzL0+PdtxPrFa+nU6HpaWl5zZz+8Ao3d2En88TfV5wY+w0etnLzbAVj7tbhN83qutjp3Ldq/29lWt3Kx0AWq3Wc0m2HRil24vs514k0rYzyayfbHsWOw0/D4rhXW1U+xUsn2CzmtyDjueZbDsQibTthp/PI5G2FfSTbU+iV6V/z9t4rZbr6vGgn9VkWzfpuF25HrS1el7Jtufu6VprmZycPDBk/NPYyT31k22FXB89ekQURbuS634l0rZ6L1rrJ3jBz2KybX5+nqWlpR1VoczNzWGt3ZM1241c9zPZ9tyVbp7n3L17d1uu/X4m0naDz3KyzRjD1NQUnU7ned9Kz7GaFzzIRfh7AWMMs7OzLCwsbPu9URQxOTnJwsLCjt6/19ivZNtzVbqrw89P8wO7mhecn59nenr6U80LbrfVd7/Rq2TO07zg1NTUp9qo7kauaZrS6XS4cOECtVqN6elp3n33Xdrtdk/vrxdy3etk23PjdPeiJfQgK+6uFe10Oty5cwfHccjzHN/3KZVKz/v2eorVSdGDLJNeYDWv+eGHHxIEwcpr9Xr9ed3WnmB1UnS7cr1x4wZhGKK1RinFmTNnSJKEDz/8kHq9zqlTpw7cbJPuJDNjDHfv3qVcLiOlZGRkZHfX7dH9bRurBbhdIXZ/P0kSms3mys8OC7oD1P/wD/+QP/qjP3ret9NTrE6K7lTpzszM8L3vfY+pqak94f/2auhKtwX1O9/5Dr/5m7/Z8894nlhd0rn6LLutoNFosLS09IRBstZSr9e5ePEiQRBw+fJlHj58uCvZ7EU5Wvf7Liws8PHHH/PLv/zLu77mc1G6ax3TspPFvnLlClevXuWjjz46NEfudB+MbsbUcZznfUs9w9M1uTuRq7WWa9eu8eqrr7K0tMTNmzdXIqJeotebc7Vc8zz/VMkVdl7Saa3lo48+4qWXXnpi9kIXQgiOHj3Km2++SbPZ5PLlyywuLvb03nsBa23P5PpclO7TAtyJp5skCcYY3nrrLYaHh5mcnGR2dvbAc6XdITpQ8FwHLaTaDXrREpokCePj45TLZV544QWOHTvGwsICH3300Z4o315h9ff+tMl1K2cUroeHDx9SLpepVqvA+lGG4zicP3+eCxcucOfOHT744APiON7Wfe5144Uxpidy3Xelu9kpoVu9RqfT4YUXXkAIwcjICMePH8day6VLl5idne31bfcMqx+MT5Onu1ZN7naNaRRFpGnKqVOnVn4WBAEjIyMMDw/z9ttvc+/evV0b1r3YnE8b075ci+f79u3bnD9/fuV9m6FUKvH6668zNjbGu+++y507dw5EcrKrtw6dp7teS+h2N8CDBw9wHIcwDFfeK6VkaGiIV199lampKd55552eZkZ7hdUe0adJ6a4n1+0o3StXrqxZmN41rBcvXsQYcyAN62pF/mmiF9Yas7pVuV6/fp2TJ08+sxZbef/w8DAXL15ESsmlS5d4/Pjxc03KHlp6Yb3wczubM45jHj58iOd5z1wDwPd9XnnlFU6ePMmHH37IjRs3DhTf+7Sn2x2ucpixXkvoduTapYbWCt+611BKcerUqV0b1r3ydD9t9MJ6UelW5NpNnh09evSJn29HcUopOXHiBG+88QZzc3O8/fbbK4nztbDX9EKe54eLXtioJXQ7m/PatWucOXNm08XtdWa0V3h6c7qu+5zvaHfYqCV0q3I1xnD16lUuXLjwzGtryfkgGtan5XrYPd2NBhVtJldrLVeuXOHChQu7imi7cF2XCxcucO7cOa5du8bVq1f3nd/vJv8Pjae72aSprW7OhYUF4jhmdHR0S7+/VmZ0aWlp+1+gh3ja0z3sHtFGWe2tyvXevXuMjo4ShuG2PrtrWMMw3JZh3WtPt1ce0fPEZknRjdZ5amqKMAyp1Wrr/s5OHKBKpcKbb75JvV7n7bff5v79+0/w+31PdxW2ckroZkJYz3puBaszo7du3eLDDz/cdma0V/g0JdK2MqhoM7nGcczk5CSnT5/e0T0IIThy5MhzLzn6NHm6m41Z3UjeWZZx69atleTZWtjtLI6xsTEuXrxIlmX7xu9316QXSnfPzfFWJk1tRek+ePCAgYEByuXyutnrza7RzYzOzMzwzjvvMDY2xvHjx/f1+I5Py+bcLHrZ6OercfXqVc6dO7drbrtrWFut1sopzmfPnn2G++/e+15zur7v9/T6+4lu9LLevthov968eZMTJ06sSZt1u7t6AaUUp0+fZmJighs3bjA5ObmnVQ5dx/FQ0AvrhZ/R1AyNa7fJomjTayRJwr179zh79iywu9GOqzPh1lp+9KMfMTMzs8Vvs3usfpgPM72wlZrczYzp/Pw8SZIwOjq642s8ja5hHR0d5Z133uHu3bv7Urv9aYlgdnpGIUCz2WR+fp5jx47t5S0+Ad/3+dznPseJEyfodDrcunVrT/j9XlYv7OmOX0+AWbPNpX/5X2GyDBPH2HLA4yyndPIo0tFI36P2+VdxhwfxTx1narDE6dOne6qgupnw1Zby3Llzez4H4dNQMrZe+GnynFv/y/9O3mxS/anXadmc4CdeXfcaV65c4bXXXtuT1s3h4WEGBwe5f/8+P/rRjzhz5gxDQ0N7xvk93RxxWOW6lfnHayndbufZVum/Xie16/U6YRiu8PvHjh1jYmKiZ/I+FPTCRuHn7F//A/6JCRrvXMGSkN9bRA+VaFx6B6RElkLm/va7SEeRdzJENWAawZ3hQdyJYUyUEp89wrW/+Ee840cZ+Ln/hMzmyB2EqJ7n8corr7C4uMhHH31ErVbruYJfjU8DvbBe+Pnoz77O0qX3WfjB20z+0Z+DVgjPZbJWQjgelddewKYZ4fnTJKfGKdcqBHsYhkspOXnyJOPj49y8eXPFsO51c8RhNaa7OaPw0aNHBEGw4ZCftdqAe40jR44wNjbG7du3uXz5MufOndswobdV9LJ6Yc+U7kYCnP3mP6IrLpU3LtB4733c0RLpTBOnFmByi1YGMVRBChCVnHy2A54ifjRNMj2N9DzsjZs8koI8Srn72/8bJk5AKWZfPY+JYvzjRzjy3/yXVN/cmidVq9W4ePEiDx8+5NKlSysdbr3GYa9e2Cj8nP+HH2DTlOrFl2h+cA2bxNBOiGYW0YMB01+9iwx85r71ffJ2ByEF3xK/hX9kkDzJKJ0+QTxY4upXv0X95/5Tyq+9RGZ2z9N5nsfLL7/M4uIiV65cIYqinq/9YZfrVr1ceFbpZlnGzZs3+fznP7+lz9lraK1X+P0bN26gtebs2bO74tkPPL2wWfazc38SshRvfJhkdIA8auGOVjHNDu5QiWS6ia6XsCZHSnCOVMmbERhDHueYNEV6Ahtb3HpI3uogJMjAZemHH+DUQ9pXbjP/rR9S+5mf4PRv/irhuVOb3nc3Ez46Osrt27dpt9ssLi72xFKuXpvD6hFttDGttTQuXwKvggoddCDIpUY4Gull5I0Id7xGOtNAlhxU2Ud7DhaIH86gKgELP/gxOJrHocfjP/8rhJJk7QQxXOeDF0+jy2WGv/hz1H7mJ9GlYO2b3AC1Wo233nqL73//+7zzzjscP368ZyHoYVa6W0mKboSbN29y/PjxTWvO99LDXeszuvz+7Ows7733HsPDw5w4cWJHSdsD7+l2j6ZZK/uZNZpIGdGZnELYGGewjH3cQZY1RltskuKNlIlnGugBDzo5KlDgGUxs8MdKxDNNyCzOYAXTidDVgDwB5Qr0RI10sY0qeeRLHZa+80Ou//f/I8f/23/N4L/4mS3df9dSzs7Orsy+XS8Tvl0c5uaIbkvoWnKN7twnW1giPF+jfXsS5XnIwMUmOTJ0yUs+ZAnOSIn00RLekTp5K0a4Du5YDduJcAZDkpkWJs+QgYuJDLpaIp+ZYXFmBhDM/Pu/RVVcTCfDGR2i/s9+kvEvfZHS6y9viV4SQuC6Lp/73Oe4f/8+ly5d4ty5c7uefXuY5brdQyZXe7qtVou5uTl++qd/ekvv7a7TfjYqDQ0NMTAwwOTkJJcuXeLUqVOMjIxsywgIIXrWadjz6oXNBNi+cYtsaZHKa+eJJh+iAwk2R5KhQolyBcoHFWpsJ8Ubq5B3IqSn0LUy0rH442VkyUWQgBKYVow74CGkQPkSXQ8RSuCM1bHGEN26y4P/4w+Y/vO/3NZ3UUrx2muvrWTC79y509NhK4fJI9osq925cxf/5NFCtm+8QLrYQNgUm2cIR+LWHFToIGSOO1ohW2jilDU2SZGmAyJDSvBHA6QjELZ4n1lcQjkWYQ267KLLCtIUqS3xvYc8/uOvcu2/+5+4/Vv/K62rN7f0Xay1aK05d+4cL7/8Mnfv3uWDDz4g2kIlzUbXPIxy3Q6t0EVXaW43efY8IaXk+PHjT7QUNxqNbV3jQDZHbNQS2kXn9h28sRFIW8jAI7p7D6/mYJMEpQyqGiKFwR/y0BUf02khAwebGty6BiEKBTwUoMs+7pCP0JJ8cQkZKEySoUOFLAXkJ06T/9Q/Iy9V6cwuMP0fvsH0//sftvWdupnwn/iJn0AIwY9+9COmp6d3bKkPYyJtK+FndPsmwekjuKPD2PYi/tExTDvGGw0x7TbCxAiZoUMXp2RRvsKkKco1ZO0EHaiCInLAGfDQ1RK6rBBSYBODP17BJhkqdFChi3Q17pFBxIkTxI0Wczc/5v7v/xkLf/+9LX2n7vcIw5DXX3+d8fFx3nvvvR1PtTqsJWM7mZPbVbqPHz/G8zwGBgb28A57i9UtxdevX99WS3Gv9mtPlW6j0eDq1asbCtC0FlGlEFUKqf/U6+haFbIUpACl8EoKqxW65OKPltElH7figoB0sYEuedjc4IYK6WuUowhODKBCD5tEIGzx94mjoBTKxpjzF7BBiZaRLPzT28z99d9u+7t1M+Gvv/4609PTvPPOO7RarW1f5zBuzjzPefvttzeUa3T/PtoDVQrRtTLlz51GlX1Mq4XyJSbLcGoB0qQoR+GNltElF6fqIqTApBluzQUETi1EBgoVuHhHKgU90Wyjyg4mTlGeRFRr5CfOwJlTcOwE+fw8iw9mmPybH7L43X/a9nccGhp6YqrVdg3rYTSmW6nJ3ei9N27c4IUXXtjye/abVtgI3ZbigYGBNVuK18KBU7rGGNI03XTqU3TjOrrkoXwPYWK8Y0cQroM/UiWPEvI4RjoS6Ti4oYPyXaTnUDkzinQ0NukgMNg4RYcOCNC+whsuI30Ht+pg8xz58R1E6CLjFsrJsUND2E6LhnGIHkzSunptR9+zmwk/ffo0V65c4fr16yte4FZw2BJp3QRCu93ecHMmH3+Mjdvokod0XZTM8UaqqNDDGwiwmcF2InQlAK1xy+7yc+BSOjmEdCQmjrDCYvNCAUstUZ7GGy+jKz6OD0JC3okRZ05CYxGVNJDDdUS1gkhaNG/fY/K775NMr9/wsp5nt3qq1czMzKZTrda75mGgF3aTPBNC0Gw2OXbs2LbyHKsj4IOgfIUQjI6Obrml+EANvOkKcCvttMnDhzglD2stytX4E8PIShlBjjtQwiQpftXDZhk2L8JR5TpIZXEHy0hHE4xWMZ2YvNFEaomwBuUJlOcglMQ9dgSUxp/8CJEl6IVHqLIHrod5/DGzixn53PyuvnM3E14ul/nxj3/Mxx9/vOWJWofJI9rqKajp3Bx5q4XyBFiD0ApnqIbyXKSj8Cfq2CxHCgMmx+Y5uuQiHY1yBd5QtaAMBgLyToRpd5CuXFa8EhkUlII/XoGwhLj+DmpsCDE/g27OgKsQrkY7hualy9z9y2/v+Du7rstLL73E2bNnuXbtGteuXdvUsK5OMB4GYxrHMe+9996OvNwoiojjmOPHj2/7vQdB2T6Nbktxd2ToeqcUHzhPt+vBbeaiJ4+myKenEBKwBkeDqlXQgYtb8ZCeJm91cCoeJk5Q2iK0REiBEzqowEOQ443WsFmGUpY8jrFpjg40QkkohXDhVUy5hi45qLkp3AfXkYGHsIbkow+Y+v7btG/d2tV3FkIwMTHBW2+9Rbvd5tKlSywsLGy6ToeFXrDWbqlY3hqDf3ScbGEBMzeNdDVkGboSosseQkscX6NDD5Nm+CMV8ihB2BypJVJJ3JKD8j2ktARjNUycIKXBZjEiz3DCQraiUkG/+QYMj+NM30E4CvF4EkcliLiDyFNULWTxG3/D5N/9YN173oqyqVarvPnmm1SrVX784x/z4MGDdZXGYaMXjDG0Wq1tK11rLTdv3lw5GXcnOKhJt+7I0BMnTqw5MvRAebpCFMeLb3ZKaB7HmCgim5/HrYTYqINNE1SlhBACKcGrl1Ghj7A5eZxiogivvEwZCHBKHtpz0K5AhT42S/EHS0XIaXKEEtiwinYlZngCIcG8/BaiMYfz4CoiTxCdJo0bd5j5xrdIHj9e9363apXXyoSvN8Xs6RGA+zlsZ7voynWzTZIvzGNmPsZ0OmRzc2hXYDptkAJHGZSwKAX+aB0duti4g81zTBTjVX3IM4SwuLUA5TkoDdJ3MFGCXwsxSQp5inAUdmAMJXPE2ATUh1Cjw5ClyLtXUSMD0FxERUuISsDjf/vvWLoz+cz9bsfbEkIwPj7OW2+9RRzHXLp0ifn5Z6Okw0YvOI6zI69zenoax3F2pHxWP0d77fHu5vpPjwztRrFduf7VX/0VL774IufOneO3f/u3n3n/H/zBHyCEmBZCvL385193XxNC/Nc93fGbKt25GSqvv4rptEnvXCs8qU4bHXoIm6MUONUA5SqkEoRjNWyeky01ipA0S3ErPmCRSuLVfJxqCdOOigRbkqI9BUkHkcXIahVbqqHTFtmLbyHyHMfEyPlp9MIj5q7cYfYv/oJ8BwmxtdDNhI+Nja2UmD2dCV+9OQtDc3CV7laRzc2ifYfKG69h4ojs3k2k72E7HYSrEEoiPa+oTnEkSivK41VslpM1GmBzbJbh+AqJRUpBMFzBKXmYKEI6ChOn6EoJm8VIk6GrJWx5uWvxrZ8Ev4S6/mNEECAWZnHSNiQR937vD8ji3Q+87nY1vfLKKzx48ID333+fTqez8vphimBgZ0mtPM+5fv06Z8+ePZA0QRfdcrbd3GO3UaobxbbbbaIoQgjBr/zKr/D1r3+dDz/8kD/5kz/hww8/XOsS/9Za+8byn3+zfM1B4H/o6Y7fbHRbPjeDNB1UpYpNU7yhOvnSIraxhHQUwnFRNkO7CqkkUlp06IO1uGUPk6TYThvtKgQWpRVeNUAFHm6gQQmIO8jBIVRzHjdeBNfDugHaleRHTkGWIE+dQc1Moh/eZO7uNPNf/4s1BbTTMKhbYrZWJnz15jzID+52kM3PocoVlInQ1RrWGJzQIVtcwCJwB6pILNrVOKGHVLLgX0su1hjcUGNzg40jtCsQ1uCELk7gFJUOJQesxS4uoOoD0G6g0hYiKIEfoPMYTpyB+giOSKG5gHx8v1DMDx9w54/+7yfudzfhbRAEvPrqqxw5coT333+fW7dukef5oWuO2Mka3L59m6NHj+L7/q5KJvca1lowBtuD6XLdKNb3fb75zW/yla98hVOnTnHmzBlc1+VLX/oSX/3qV7d6uZ8HvtFzpbvRombzc2jPJXjhPLpWJ//4LkiJbSyiywECi5ASHbhIJdDlEK/qozyNTVOcWpksisEaMAbhaJSrUI5CaIlbCyEI8R58BJ6HWniE6+QIU5TFqKEh7MAIKlokP/caamkabn3A4tWbLH7jP/ZyKVYy4avn97ZarT2dbv+8kC3MI30f7WmC8+cK2T66j/F8SFIUGcZakAod+qhKGe1qguEqynOwuUH7mjzJUI7Cag0mwwlVkSgV4E0MYz0ffec9BBbZmMdxzErSTtfKUB8CJVGvvglxG33zXUTgk3z/H3j8/cs9/c6Dg4NcvHgRx3G4dOnSEyeSHAZ6Ybtot9tMT09z4sSJHV9jPwbedBVu908vxnpaa1FK8c//+T/nc5/7HKdOnVp57dixY0xOPkthAf+FEOJdIcS/E0J0M45Hgfv7qnTz+Tmk56EdiapWUZUqTIwj4xjiBB36WFNQB9IPkEKgPRcdeEhH4YYaIQR5lOCETlHhkGZILRAClJYwMkE+MIbyHWTUwn94DVmpIuMWOu8gqjVsqY6SOemRc8jmAtHcIs1LP6J16ZP6zl5ZZM/zeOmllzhz5gxXrlxhYWFhhXL4tChfG0cIxykUr69QlQq5XyI4PgFpSt6JcEpBUb3gaKRWy1ULLk4pQIU+bjnA5gaTZDjVACwg1Sf0RK2GPXoKKgM45QCxMI3z6A6qWkFkCdKkyIEBRLmKilrYM6+AcnDmP4bmEgt/8ofE8709UWJ1l1O73ebevXs0Go01E2mb8YBCiH+1Hg94EHDlyhVefPFFpJQ9qbfdK4/XrlK4GAM9GGzedZSyLOP06dPP7Nun///FL34R4JS19jXgm8Afdn8VetwcsZkSyRbmEEqhPYUeHESWSojWPGJwCIxBYgoKITd4AyWQFL8f+qgwRGlNMFJDaglZjnIVJk7QjqTYpSAqFSjXEEqTXbgICEp3LxdKobWAFhkoBa6HGBgiHz6KmvmYljdI83vfJrp5vZdLsoJqtcpbb72F4zhcuXKFO3fuPPPgHdaNKdMWwtEIpdGOxJRKiDDETdvYwcHCG80TTJZBluKEHiCQWuLUKyjPQyhBMFp0NskkxhoLxha/qwRZUEPXq9jqAOQJ9sJbiHaDYPIDEAYRtdHKgOti/bAw4ENjoBT6+DHsnetM/p+/vyeb3XVdhoeHGR8f5wc/+AELCwtPtJjmeb5jHvAgYHp6GqUUg4ODwO6aHPacXrAWrMUYsGZ3vO4nl7QrsxfGx8e5f//+ymsPHjzgyJEjT/z+0NAQ1tpuJv33gIvdXweO72sWpzuQRCiFDjwiYwgGBnCOH0eUQsgz3HoFk6SYTgeh1HI9r0KFXjGxSiu074KrcUseeZySRzGu7yJYJtHDsNh4eURy4mWy0gBu1kS1FnBmHqBKQVFahMEMj2MHRhC3PiCuTdB+722y+bk9oQGEECuT7i9dusTDhw/59reLetLDsDHXe4DN4hzK0StGMrY5QWDhu0kAACAASURBVK2GLpeQR48gXRdMjlcrkUcxxMsJKCFwfI10naKhwlPIsBi/59XL5HGKTTNEfRCxrLip1qFcR6ct8qPnwBo8aZBLM6ilGVQpRAiLUAIxXlQ4yOYC8uwFsn/8ax7/zd/t2dqUSiV+9md/lizL+LVf+7WV1374wx9y7ty5nfKAzxXd5NmLL7648rOdKt19ieyWlS7d++uh0s2yjFdeeYXr169z+/ZtkiThT//0T/mFX/iFJ37/4cOHq//7C8BHy//+j8B/vq9KV7RmweQIa0EacBycsIQmRZQrKN9F6eX60CjGDV1sloMFN/QQQiK1QpU8hB8gpaA0MViscZYVQ26SNg4pubFYpZGeQ14bxToO5sQLyNYiwYP3Eb6PTFq4NoGgjAkrRO+/jdEe6eT9zb/MDmGMQWvNL/7iLzI4OLjCBx30jbnRRjPNBk45AGOIog6VehnlugjXxyFFl8KiSUIZbJaRxwk6dIsNYcxKU4vQGne4ji6FmDhGlwNsmqEEiKSDyhKUI8mkBD9ADtTJB8eRUQNx4hxybgpn+i5CSoRJUeRQqUGljpQGRsZp/l+/h1zc3qCTraC7MaWUeJ7HH//xH6+8Njk5+UQjwTZ5wD3BVhXgnTt3mJiYeGIW7W7phT1TvraIjoxZlUjrQXXQaqUbBAG/+7u/y8///M/z0ksv8Uu/9Eu88sor/NZv/RZf+9rXAPid3/kdhBAfCCHeAX4V+FfL15kD/ud9Vbpmfgbp+9gsIWo1KNdrCKWQnocYGCh4Pt8jODqKUIq80UCXfGyeYZMEIUUx8MZR6JKP9FyEEujABVn8rZqzuI1p3FoFsgRhMmx9EFOqo7KI9IU3AUFp5lbRrdaaQzmyEI7WLP7wR8T375Jvo7V3O1jtQXuex5e+9CXgYG5MeDL5sW5jQKuB6DQweU4Wx4Sei/S9wkC6Ls7QAMr3UFrjDdXAGmy7CVhMkqAVCAFoWVSueC468HFLLkIrRKuBHqgjG3M4rXncchljcoQ15MPHMLURnPYcZuw4cmkWz3aQrSVk3Eb5Lizzzc7xYxCWqH7rmz0/R2ujOt0tVsb8e9bmAZ8bOp0Ojx494uTJk0/8fKdKc/UztCc0g7VFkr1bvZDlxd+7/Kxut2GXq//CF77AtWvXuHnzJr/xG78BwJe//OUVj/crX/kK1tpXrLWvW2v/M2vtlU9u0f5+z5TuVgRhm0s4niJpNnGFwCsHBd8nBcpzEUGAcjRSCVQYFCGnAhMnmCgq6jazDCEkbjlAKIVyNE7JL6gLqchOv4JqzBFOXUH5PjrtoE2EdZa5PpGTjp0i90J0KUQvTeM+vo0slZB5igWWvvtdOt/51p5Y5PVoi4O+MTeqwTbNBjaNiB1N4GgweeH5Fm8s5mw4zrIy9VBBgJASt+RhohiTxAjfKRpsBMuJU13I98gRTG0Q/fgeDIyiFqfxFh+ipUCaDCVS8qCCKddQtTqmMoiam0SOjiOX5tCNGaTnFsdAWYOcOIpsLTH7l9sb87kZnm56WT0o+9ixY5vygNba2XV4wOeG1cmzp3Egyx27Ctca7IrytbsuHVvt6R640Y4bwRqDaTWwsw/JsDgYRKdRKMvlEyK0U4z3047ErZUQnovUivD4EWyekzcaCK/gbkWWIpddJKEV0tXYoIQTLZFOnAWTUeo8RsUtvGgR7TuYPMdKVUyoqg4jbE5y5nVkZ4nw/vsIt6h4SNE0v/0t3FtXe78O6yjdg74xN6rBNu0mpt0mtBEyz7BJjEzahfeKLbrMAhfpODjlEG+wigo8bBojfbdo9zYZYjnbrBwJSiKUQgQhdmAEUxtGkWK1g1ycxtEW1V7EiVtI3yMXqohWTp7HDIzjTt/FVmpFI0xnCZHGxXOmBJTKRD/8Nq2793q2Pk/LdbWi+vznP78pDyiEmFj139U84HPB9PQ0QgiGhoaeee3AVt1YMCaH3HTz6rBMNezqsquU7oFpA94KbLtZVA3EEaXRYWy7WTQ6lAJEliLyrDiCRXxS/iWXw0KBQZVDkBJH2aJULE5QrsYag0CgXIX1QkxQhkqZrDJaeNGjEzhLjwkX7qMqFUgjSGNsZYA8rKDTFvGZ17FK48/dR2YxqjVHkkvCj94lvt7bZ78rwKdnGhz0jbkevWDzHJTCRh3cNMIZHMbGETaOUJUKIs9ASLTngusWtdW+V3SoeS5eyS+4hSTBrZWwSVrUZAceSIH1S8hSCRuWwQuwJ89jSlWc2fswOoFuzOI3p1Geh7E5Ik/IByfI6yNoX2O1Qs48KBJsy5SDLIWgHeb+7I/J0913q8H6xhSKAvv1eEAhRFfIv7oWD/g8YIzh+vXrXLhwoafX7T5De8fpGjAUjTR5Xvy9XNO/q8uuUrq9aHrZP6UbtSEIyR0XpzGDUBrTasDcVOHRpDFYkI4DLCveSjFVTDoap1ZFuC5CSLyj49g4Jm82cMoh1hqkFNiwArKYAZGPHCMtD6OjRaLjL6M7i1QeX0VphU7aqLyDVU7RraYF6egp8qCMCEuo5jx67mNEauh891ukHz/o3TqsYzU32phdgp7nuDHXVbpRGzt+DKEUpAlKZthWAxu1ixkIWQrWIlxddKIJWXi+y/SRcDV6eBDpuuRLS0jfLQ60TBOs4yHyFEdkhcL1PJTNyI+cJauN4i88wFQG0EuP8ZNFdJ4iTQaOxPolcH049SI2KKMeXEMMDSMaC+jmPDgaOg0e//n/05P1ebq9+2msxwNaa7+2/P5fX48H3EusJdM7d+4wPj6+q4Mcd/K5u4Exy97t8pAmayxm+f+7/ajVJWMH+gj2p2E7TTrlOhWTIjW4Y6Oktz7Cdlro0QGyR4vgF/Nz81YHtIt2JLnpzuDM0aUQcoPIU2S9BlEHG3UAAdaipSE1puhqkzlZWMOmEdqmREOn8BqP8LMmeRTj2JiodgTbbiE8FyoVjACZx2SnX8W9+x7BzAPiwEF++5vIf/lF1MCzoda212GVAJ8OVb7whS/whS984YmfffnLX1793l8Hfn3XN7EDrDdBLl6cR9gYGZYQEkRrATk4gl2cQWKwlVpBN5ChfQ8Tx4BCuU5xtJOUuFqSm5xipoYii6JiENLQILbZgCDEKdXJOykojVaCrDyAyEKUlJgoxF14iJ04DwuzxXMQ1DBxB21yOPkCdnYSZ/4hmeMhF2eQWmOswFx/n/l332Xgtdd2tT6rI5cDyXeugbU8z06nw9TU1JbPPNsulpaWetIl9gyModC6BZcrsGBysHKZ4925h73Rnt0J9s3Tnb5/l6AUoIIQ4YfItIWsDiI8H7X4GOsXZULEURFO5lnRMOGo4lRgVYSo0veQnl/UgC4nZHRYzOf1WrOIMEAlbVSeFENXlMa6PqY6QFodQQiwY8dxmrOU524hK1VE0kYm7UJBBBW0iYlOv0kWlOHxfZIHd+j84zcwnd0Pxlnt6e7kVNLnhfU83btXP6JUKeFMHEMEISIIcUeGQUlIEkITFd5wliDypAj7jEFqidUa7Tko10FXSkVUIwTuyHI779IMjIwjW/M4zRkoVQqDa3NUuYLxQqx2SY+eIysP4s7chaEx9NI0flQ04lhhEWTYgVFsZQBdLYEUyMcPikFLzSWib36NeJORnJuhK9fDonBhbUN69epVXnjhhT0ZxBTHMY8ePWJqaoqFhYXertVy0qz7x1pbNEfkRenYbpJpXdn26gj2PVG6Ty9mkiQsTE1SrlWQ5TLC9VGej3P0OKJUDKVWtUoRCqRp4SElRWG8FLZQuoBQolC0Si13M1URnocQICs1RJ5Snb6GKdXR0RJeZx48HxAoAdnAOGk4iE7btE++jsxSalMfFEo8aqLiJXKtMNpFiYxk9CRZdYR8dppsapLoO39bdFXtcm16aTX3C2splNnZWUQao/0AFfgI30f4ISqPUIOjEIToPEGNH8PGCTZN0KUQm6ZFxFIuIYQEsTyAXivQCikLeealOs7So8IQNucozd0BpZBJB521i2FGykGTk46cJKuO4rRnMKUazsIjPCJ0GhfJPUdjvAAcF06cx5YqqIe3EIPDyEf3Wfz//nRXHpi1n5wIIsTWD3l8nnhapjMzM1hrGR4e7vlnWWuZmZnh6NGjjI+P02w2eeeddzY9aWbrH1B4uitdaMsK94mW4B3i6ZKx3aLnSnetzXnt2jXGquUiMRYEoB1wPKQ0iCAEL0TZDHXkOMJ1IUvQA3VsEmOTBCcMIMuKzbncsYQQSK0QjgZVdDV1Bo6TuSXKzY8BcNtzBOkSwmbFOEBhMEGZzCuhbUJ79CxpUMGP5lAmw2/P4trl7DsW5TjkpUGy0iDZxw/IW0uk7/7Tri30YVK6XeXxdMmYMYarV69ybGQItC7qa4MSwvEQno8zNo4ISuSuj5ZFso0sg7jYZCbL0CYtuGBTGCLleUgpEFJih8awYQUbVhG1OsYNkGmEnzWLORqdJbRNi2FGFJfPKwPkYQ1ZrpD7ZdzZ+4hqFd1Zwk3aWD/ASI3EwPGzmIFR9OzH2PoQvPM95v/ur3e8TodtelzXMHTv1RjDtWvXep486+Lx48c4jkMQBCilOHr0KKdPn+bDDz/k9u3bOzoM9AlYizBFuZiwdjnBznLpGHxSzrCTSx9QemG9IvrFxUU6nQ4lXXg02ncRWheToVwHVR8sFK3rFxlmLyi6xYRBOA5kGSJNinA1z7GdFtJ1EMu8jXRdhJSFF1Opk5YGyfwytjaEzGL8xhSO56CjJXRSvBcpsdoFPyAtj5B7JezAEDKJCObvoctlVNRApR0IQ6wbkAY1sg9/jM1S8umpXa/XYZtE9XTJ2L179xgdHcUxWTGYRmtUuVIYQe2gRI4ISxjHQymJMz6BcApZyXod4giSGO1qbJYWnWnu8noojXAcbFgtOs+UJD16nrQ8hMhT7NA4TmsOf/EhMiyhkhYyTxB+AI6HUQ7pxGny6gje9F1sfQS1NIMfLSCd4jOkyLGDY9j6EMpm2Nog9i//hOb1nZUJHsbpcavphbt37zI2NkYQBD3/HGMMN2/efMaD7h55pZTi8uXLzM3N7ej6dqXtt6hW6NIJdjmhVgzB2b3SPbD0wtNdJ1euXOGll16CqF2MbsQiHLcoExIS5SrQGqs02nWQ5VIxV9d1EQN1hOsVhe1hWJQiRR1knoLJIM8Lz0hJrPZQSpCVh8m8KhJD8/irZE5Ieeke2cA4bnsOv/kYgjLC5EgsealO7lcQQHzycxjtUZ6+Sl4dwu0UXKJxfazjkUmP+O+/Tv5w923Ch2HQ9Wqslmscx0xOTnL69GmIOkXbrSwoAlTR1CAct2hWUBo8H+V5xdlmno9II0S5AlmGbS4Vsk2T4vil0Mc4PsLkaE8XFSa6oBCy+hh5aQCdtukcewVhUqozV8krgzidRdzOPNYvSguVNaTDx8lqo+j2PKY2hFqYxo2bxYD7LEEogQlKEJSQ9UFsfZjoz/4N8ez6h1quh82qFw4iujKNooiHDx8W8twDdA201vqZKKA7AvXVV19lcnJyw1NX1kNRFmY/aYZYKR37hFqwu+hM63UepudKd7X1nJycpFarUS6XizKg5QXoDiYHkEIgXB8rBCgH6TlFyKmKEiNZqRRzFpRAT0wUC9huocolbJKAyVC+ixXF8GutLcYJMG6Aa1PagyeJw2FKrYeklRHc1iyVxbtFSJx2cG2M8UKM46NMQnz0Akl5lNLCfbLKMF5zhqAxRQ5kTkgex8R/9zXSK+8W3OQOcVjohS5W0wtXr17l/PnzxQMolg3s8tQw6RVH9gopizpqpRF6OQFaH8C6LtIPcGoVhOeDViiTFpsiSRB5XpTuJREqaRcnQUDR5u1qcq9E7pfRNqEzcobUr1NZuo/xApzmLH57tmiesTkSQ16uY0o1pOeT14aRi9MoJVGtRZxOA+G45IiCnxgZxyqHxt012683xGGjF+ATpXvlyhXOnz+/J8mzJElWDPRGRsn3fV599dWVU1c2Oo/uGZhPqhaKGt3u0BtYriMrKhh2yOuulm0v1mjPPN00Tbl79y7nzp0rPqhSgTwrBt7kyTKXl4PNiyTM8vuV4yBcFwNox0GGJfCXaQdrioSZ6yGiDrJUgjRF5hl5dRidtdFZhAiK5JlRGuU5JH6NJBhAOZK4NITKOpTjWWQW4URLuCRFsYlQKDKS2jhJeQTHxqS1UZz2HGE0i00iEreMWZgn+vu/JLuzs2Pc4fDSC/Pz86RpysjICABKCbAgltsuZfBJbadSAuu4BTWkXZRWGKkQrls0v9TqSM9HOA56eWwgJsclLipKoiZetFBEOss1uCIogdJYx0P6PklpkDQYQDkaox3c5gyuTVBRC522kY6D0W5BJw2MkNdHUZ0Gdrml2F2YQoalguLIUuzAMHbkyFpLsCHWa3o5yBBCMDc3hzFmRZ69xs2bNzl16tSKh7jW7IXV/x4eHubixYvEcczly5efGA6/PuyKp7ty/a5naymcveWa3Z2g19TRnindGzducOrUqRXFItsLYDJsmhRH5pRCyBLIMlSerJwWgBAFx6skOD7CDwpvR2uk46DKJfA8cFykkiyPJaPWuIeVDm68RBDNYVyvKC0StujNdwKM45MPjhOHw4BFVKq40QJe4xHa06i0ONxSOprML5N7ZURYIakfQSYRnjTouEXmBOSPHhQNHzvEYfN0uwrlypUrXLhw4ZOHMG4hXGf5wTYozPJJz8UmUL5bPPBCFqVavo9QRfJTaVlUEzgOQljk0AjGLyGTCEaPojoNdHsR16bIJEKlbdyshdFuwedLyEv1gsPXHtnoKVK/ituaQVRr6OYsbnO2KGUDhLWYoXHy2hAqbpEdO49oLeI9vIkMQ0QSYU1O5IbbXp9et4ruB4QQ3LlzZ8+SZ61Wi8XFxWfa2Z+GNU8m0ZRSnD17lgsXLnDz5k2uXbu28YAi2/Vm+aRKYYVasMuzmbt1vNtHrw3pntALjUaDpaWlJxZbxG3kwAikMaQxsr0EjrfSfaQ9p+hCQmCFRAQV7DIHrDwXpCrKhZRElUrFRtUKWalitEeufBxlUWkLP5qjnC4g8wydRfgmItcuVmoklnjgCEk4hDIprbEXUVlEee4WtlzBiZdwkgbCD7CyCI9tfYS0NobAYgbG0HGT1tApbt+6RbPZ3NE6HUZPd3p6mqGhIUql0icvpHFhCE1WRDJ5hqzUIE8hz3CkLZJiy+GdEwYgReG9OnpFCUvHxZbKmKCMCaqouEUycRYrJG5rFlEbxGkv4ESLeBTHsss8xbUJxg0xjocUlmT0FEl5GLczRzJ6Cqc5QzB7D+v7iDwpDHylhgkrqCwmP/0KVmncqVtI10OU6yw1lrbNLXY35mEypu12m4GBAcJw+0ZmK7h27RovvPDChgqrmwRbi0oolUq88cYbVCoVLl++zKNHj9amHGx3qM0yd5tlKzW6xuTLNbummMmwA6wuB+wF9qRO98aNG7z00ktPLnYSIZNmcXxG3CkOkPRdiNuIpIOXdRCVOiaOiulRWqxsYmHyomsMilIxVxcZc6URWpJWhkn8GkIKWmMvYhH48Tza07jxIm7awJV5cR3AETmZXyP1Kjg2pjnxOTKvTGX+dsHjtmcptaaKpIw1CJtja8NkpTrSZkRHX6Zx+qcpvflzXL16lRs3bmx7VOBhU7rWWqanpzlz5syTLyQRMo2KiCNLiuPQk1bhVGQpyuQFxdNqFUlUkxeRzLLXId3C6838CsLxigYV18d6IUpakuoIaVDF7cwRjZxGx02C5iNk4KGTBk7awpFF2RhCooUhq46SBgN4aZN47Cwy7RDO3QWlUHELJ4uxrlso6uW2YlMZREdLmLGTjI6OrXCL9+/f31L97mFreonjmHa7zcTExOa/vAPMzRUHAXRPm4C1O+CszVcmg60FIQQTExO8+eabzM/Pr13baz+hEoQF0nwl0mK5VtfaQinvBL3m6HuudOM4JggCqtXqys9sXigkYXLk+PHl4akW2VpADI4VPftZgujMY/MckcbIJEKWK8sbOUEKs4qfMYX3u3zikPADMrdM6pZxbcLS8AtEbh0vXiQaOIEfzVPuPEL6QcHz5QnSkRjpYHRRR9qpHycuDRNEc8SVUdz2HNWlu0X5Uxah8qigKdwQZVM6I2fRtVHeeustgiDg8uXLPH78eMsCSpLkUHhE3Q0yOzu7koF+AkkMeYqq1SFNII2LM8vqA5B0UCbDthZJXQ+ZZ5BlSMUniQ6pySqDnww6kgLr+VjlgPagVMN4ZTK/ipe3aQ2fJlcepcbHZLVxvM4cQWcW6TnINEKaHKUluRuSexWkFsTDJzGOjxstIUyO05xF53FBOVCUj5mBUUyphhmawPIJt5imKZcvX2ZxcePz1bre0GHxdB3HYXh4eM/Gl167du2J0ya6eCbZaLozcDe+puM4XLhw4YnaXtPtNOsq1+WRjnY5qdZtkujSDDvUuc80vuwWPa3TzbKMZrP57ImhSQSOD66HJIOwAl4AXoB0FfghuXIwJkcOjxWLlCXI9mLB+SURIolRYbjs/RajIJESBBjHg2U6INc+WlnicIjYrxOkiywMnUfmKbWl22SVIbx4ET9ehOXkHKIIddOgTurXUErSrh1F5gmVVnH0ho6W8LIWRmmMconqx1a+99GjR3njjTeYnZ3dcpfNYeL+FhcXybKMWq327ItJBGmCaC0UA2aSqJBXYxrcAJ2nELWperLYX3kGWU5eHV7eD6Y4Ql2qlahGel5XG6IkZKVawcd7Icp1icsjJMEgQTxHc/A0OmlQWbiDLdfQSQOdNMFfnl6mHEQQkpWHMF5xWrS1FndhCm1iSCNkGiMlGDckGf1kYLdSijNnzvDyyy9z584dPvroI5Jk7alkXSVyWJSuUgrXdfek0uLhw4fUarUnaaj10C312qJGXF3be+nSJebnZpdLwnIEYrnt9xNla7se9C7Kxg50Iu3mzZuUy+Vnw6skAtcF7SIdFzE8UWxQb3n4+MgRMu2QKQ9HGGx9GFy/KDVafoBFliJai4X3m6aIPEe5DhaBMimujTCuX5T/Con1QnInJPHKuMLQqJ4gcavUmg+IS8P40Sy15gNMUF72ZBPwQ4x2MY6PDau0KxNkjodLijApbnMaL2+TBDWMVE+Ena7r8tJLL61Y4lu3bm3YZXNY6IVuSdHY2NjaD2yWgDHFug8MF6VXqjikUtbrGFFw9CqPYXAUkSaINMJtzWKDEiLuIJMOStpiRnKWoJMW+CVEXpwO4UiLURordTFGMqyQeiUSr4orM5oDp8m1T3XxNmlpELczR9h6hA1ChMkAiy1Xi7Gf2iEfPkrmV9CNWbSSyE4T1ZzHVirkyiVJkidkG4Yhr732GkNDQ7z99ttMTk6uuRa9HHS9H1hviNFukOc5t2/f5uzZs8+8tuZsipWE19Y/48na3gdcvXKFOI4R1hQOc9cDNvaJ6LjL+W4XB1bpNptN5ufni5rcpxbWZgkop2j/VU7hoHoB6EIRC2mJ0bhhGeEFSM/DOh7W8xFaIgZHsa5XvDeLC+83zyBNyKrDOEkTJ23jixiMRdqsOCHCLWGEQ649rB8Q+XWiYACP/5+7N4mVLDvv/H7fme69Mb0hX46VNahYRapYFEWKEiSoATUEghJACFQvbEILQ1y0AS20EGCAAAEDWggWQHtBe6GVbEGgYFuy6AZEodESTKq7Vw2ZoFji4GKRWQNrrsrK4Q0x3OEMXpwb8eJlvhxeVhY7sw/wql6+iLgRcc893/3O//v//1/DYngG6+ec2n8pc3rbA4p2n1gMM+dXCXG0RVduEWxJGJ0iiaI6eIc42IAEi3rBbDY/8n2Xd2JrLf/0T//ElSuHRPv15z0sGdHe3h6bm5uUZXnTvMau7SXdLsu6YwPbZw9vqCmwX0xQ1RDKETo2+K0zeW61yT3MRJCuQc/3kI0tdDNDtQuKZpdkLcrX6NBksUy/DdWSCMUGURdEUyGuoB6epqlOUbV7dINt3GKX0d5rWRHXLjBdTSxHJOMyE2PnEfx4B/G52aVaHJCKIfTKo739feq6Xn1XEeHMmTN86lOfYrFY3ERnWm/V8zDMK7z/Xme3soV85JFHbus7e+R9lx0e7mHvX5YlH3v2WU6f3uFHL/yQrt+FpNAzFtIazLCkjN1D0H1g2QtN0/DMM88c29ZFUkDGm7nYojViLAxGK+pQQEhlr1qy2eya4TgvaJPpRAwnmSpmHHo4yFxNEcr2OvVwh6LZY9BeR5cW62fYsKCShqR1NsQRhR9s0JkB3g5J1Yjp8CydqRg3l4mmyKyH+jLJlqjYYZLHDzcJtgKtaXYeoy03aUZngSwIaJqW3b19muZw26mU4tFHH+Xnf/7neffdd/ne977HYrE4csd8WBbn5uYmH/nIR45doBI6OH0xz5lxiC2RwRBsAbakTYKrCqQcgCvAVegyF8liUWU+9qnzxKIiGYeeXqPbOodqa0wzpQyzLHhpZzkID8bo0KBih5M2q9VEIUrjBxM6N6IrsglSMzyNxMho+jYowdb7FM1+/qwCKgXC1g5huAEk/NnH6LYv9NCiJiVY1DX7+/tHiqRaa5566qkVnelHP/oRXdc9dPAC3L4F053GcdfD0kXsJnhx7TU3jWUW+j4y7u2tbT76zDOkmHj++R8yn/X993oJcFoW6paB+ITjfme6920fdOrUKbqu4+233755y9K1OZAGn3FYpRGz9LmM1E2L63XzxEBQDnSvVgsdSEKS5JMmvVfmaEjjFUkZSmrmgzMM2mtszN/i+uhxxvuv4U2JuA1C2yFElALvBrmVt0AYnaKuLTZ1KKXwaUDZ7GJiw9RtY/wcLZG2HGK6GqWE+tQjzDZzP8iUhCgaQmB3b5+icIxHwxW8UhQFzz77LNevX+cHP/jBkdYnD9M2FG6xFfUt4gy0FkxvPKQNcbRBbGuats3eGKMJNIvMXkgQ9AaqXRCVzu5vG6dRzQwR0gFSjwAAIABJREFUhU2eZnIK09YZGhhsoHffQUKNDQ37g/MUs8sk5cANCW1AkmABX44QX2f7zsmANLfY0GBVznDs/FpWHdoREloMiTCYoNoFiog/nYNFkkRIOsvEO0+7t0dRFIyGw9XiW9KZ3n33XZ577rlV4H2Y5vV2LZju5rU3Bt1Lly7xoQ996Lb0qptEEev82ZT6IvsJRh9ItVIUzvL4xcd4+fkfU5YDHn30IsqonlKWshirdyE7SRBN6eSvud34qbiM4dvst+CyUmz5PIqSuq4pCpcxwTKbbQgJRBGKIV4XBN1nwOWApA3RlrTFJt34NMFm7DYNRszLU9R2zKi9yv74IkU3Zdxczp1g/RQXegiivyi0JLrBNp0bEU2JH59mUZ6ClBh2e6iUKOpdBt0eUWeTHZ0i840cdEOMtF2ki4K2Du9z8J3PF0fOwdbWFp/61KcQEWazGVevXj02I/r7v/97PvKRj/DUU0/x5S9/+bhzW4jI/yUiL4rI/ysiT9yfWbvzOHaB+i7P63g7w0cqNwfFOeq2pSgHJFQ2LrIFqEz101aTbNHjvzb/uxiQrCMaiwyGeJfFKYrI7NSTeFORECaLt/BuTNHuMlhcQZUF1s8xoaGgJWqbZcgCfrxDV06IxhE2dgi2xNQHVO1uzqDrKbY5IBYlSTu6yZn8vRLEmGi7iE8axNA0Ldd3d49wd0WEc+fO8Qu/8AvEGHnuueeYzWYPzby+H3jhxtceHBwwn885c+bMXR8jt9RZy3Tv5bOkpQAiX5ulc3z46acZVgN++MMfcvW993JxbcmQuIesOqVECOG+3Ux/akEXlkF1qR5JREm03lPY3jUserBFlvvGgCaSjCMmwYvBu4rGbdDqimhstl7UBUFZkjY0g1O0dkxjRxTU7I4ewyvHuHmXdrBD1exStrs4la0edWxxqc2BWzuSKJrJWepym2AqcJYElPOrDNvr+avYAVH1xT0k6/iVIiZFkhxU6rphb/+Atj30ZlBKcfHiRUajEW+99Rbf+ta3jrAcQgj8/u//Pn/3d3/H888/z1/+5V/y/PPP33h6/zVwPaX0FPA/A//jfZy6245bzqvS+YbY72AQRRShE4MrMwtBAIryMFMQhRRFb3ok+XVFCUpn60VtCMONjKXbEiuexdajNMWE1k2wKlFXp1CpY2P2Bt1wm6LZw3VTCuXz9ZMiJnUrNSJK0516hHawRRLBkhe8nV2nml7Fb5zJu5a+C0nsW0CJCBEBldtIzedzDqbTI0VSYwxlWfL000/zZ3/2Z3zve99bUcwe5Hl9P/DC+kgp8aMf/WgFQ91qrPN0V1v+Ja1rqSo72RuvCmRLXm70AZKwc2qbD3/4w+zt7vKjF35IPZ+TUrjnQtr9chiDD0iRdqugi+q1+DFCDLTzOdX2DhI8OgUIHaLpSfQdErpc1SYhwSOxQxeG6LvcTpsIZbVyLDMq0RZjgi7xZgDWMC22WdhNBvGA65OfwYSa0eJdtDO4borzMwrq3CUY0ETa0Q6NGxO1o52cyQu9mzLw+9TDrFFPAMqgJDtsiQAiffDVhBDZP5iyf3C4QFNKGGP4uZ/7OYbDIX/+53/Oiy++CMC3vvUtnnrqKZ588kmcc/zO7/wOX//61288vb/NYdv1/xv4tHzAQv9b+ekCeV4lZ7KpHLCMsIv5nNH2Nvm2lBeDktjfUFMOiqSc7RKz6hAIxva7S8FoCC7TAKO2aJXoqk28HeBtga8mLModGjdh1FxhtnER1+4xWLyHtgrdzdGhwaYuqxF1ViP6jbP4cpNoChiN8cUAXe9nzJl+gaFRxqGVRoug+nMQkiaJoW079vf3WawV2gDG4zG/+7u/y8bGBt/97neBB3de4f7BC1euXME5dzyl8HZjrWX6MhE72evTqjiWYsjCiJ6vG2PEiOJnHn+cRy5c4MVLl3j91deIwZ/4fVLKfdceuEx33UHoZky3OawcllXGbdsGSYECD8ONHHS7BmkXyGCM6trcmbers8uYb1Bdg26mpMEI7bOgoogLoi1RKWc4RgteWZIYxFh8OaHVQxozoqDh+vhJGjtm0FyjHZyibHep2msU0iDJ9/SzFl+MCLpARNNsnGNR7ZBE4Yfb/ffMIcWjSX3hJcYM3nch0npIKOq65fruHl3nj+BCjz32GF/84hdX1Jo333yTRx99dHXKLl68yJtv3uR29QjwOkBKyQN7wPtv3HYX43h4oT3E4MoKBLq2RYlgtUKqISqlQ2WhzlxdCX33Z0IO2ssbqkRQKqvWUsQYRRK1/ACIzbTCqAtEG5rBNo0ZUbsJRViwt/EkEc1w/i5xMMHVe9hmHyeBpbm1JhCGk1XxLk22aTbP007OLr8pSiAmhccQRa8SsZQSXch4b0iSt9SLxZFTEkLgYx/7GL/2a78GPNjzej/ghWXn4KeffvrkB1kW0VI6/DnZAQ5b9KyOcSiYWGKxo9GIjz7zDEppvvvP3z2xb2+M8b5i9T8leKGDFDKQHTxptEloFhSKXGRrZ3jRvaKpRTf7+PGp7CwVOlyzjx9uobsFulswrK/RDTcw3Rzr54ziAVEZTKxxqUY7iyIgKWEl4t0QryzeFGgjzKozWbEWF+xuPYWOHcP6Ck4ndKixfkaZFtmdSgRJiW60Q1NuMhs9svpaidQvRGiDJokm9heAUsttqUFlCdYR6knXdVRVdVs7wGOSneOyn/vPbj9m3HJeV/hBIhYD6sWcqrB9oO0I2ubg3LWoboEvxis+rvItymS3OekaTMjdViVmEyQTmlyIix06egwduBzckwhGQVtt5J2NHWA0TEcXqN0mZbPLYutRXLNPOb+CNZJFEKHBxpbYZ9GiNFQj6q0La0Wc/P+YEj5KznBR+BAJIRJixEdB6QKtjnLSb1ycD/K83g/2whtvvMHp06fvyvz8JhlwXMNy7yXoxiUkkQNtPj5rcMXy4YggXLhwjmd+9md564S+vQ88vHDs4gzdClIgdMR2QdQO6TvAojWhGmWVmiszZQtPOzpFsEXG9VJLPT5L7LPYQTelqTYxocZ1M0aqRkiUfsow7BKLITY1mNhSqo5ochEviQJraeyIxo5wtFzb/DC1m+C6GRQDXDelaq4ziLPs9ZA8JnX4aoPpqDfxSXmCfUj4kPoFClEM2liUUn3rGSGiVwbOt6KMXbx4kddfPzRHf+ONN45zZ3oDeLQ/zwbYAO7Nbv+E49h57RpW28KUaIPHuAKVYg7IoaUoe7l2u4CupvJ7LAZn+my3Q3cLUjFA+Rbd1dh2CoMRuqsx3Zyy3cs90kKN8TVVnBKKITp2KAJOfM5+lSYqixQuW3kWG7i44OD00yRRFPP3UGWBaaaYdobzc5KxOQMWwQ93+jDXW+338cCHSOcTjQfRFmM0psfxk8hN2c/DNK/vF17ouo7XXnvtnszPM3MhrFHG7gHT5fA1KcYMX8ZwiBMv6WJLqliMFGXJx07o2/vAB93jqEVxuLnKfFLwxBixWzs5a7El2AJtNGnzTMbWbJGr1a4k2AHRFERbglF0gy1CMcCbEmWEWbFDq6u8nXBDIFKGGafat2nKTcpwQBFmDGVBUgqdPAZPcgVRGYJyWAnMB+eoi00UgdnkIpIiVXONYZwiRKyfQy8BhjzVObu1WKMxWtAq/4SkiGikP71ayU13+RsX5y/90i9x6dIlXnnlFdq25a/+6q/43Oc+d+Pp/VvgC/3v/xXw79NPyTH7uHlNtjjE1IIn+A63ud1LfRvoOowk0nizF8IUeF3gpGU2vkC0RbZpTIF242xWAyqDaec0kzNI9JjQMGku0w53KLoDXDdl0r6Hd0NsmGNjQ2ECIoLq8eHoSoLJ15AhMNu8SFtuYNoZfrKDaaa4xR5luwva4t1wleUmwEeY+7xzMVr6n9xuKiQNsuR+50Lq+riRlfIgz+v7zXRfffVVHn/88Xvfdsc1Y5plMewkow+oK/WZqL5jRN+2p+88vaKmxbSqvdzo23twcHCbt3kI2QsheFI5JMWQb2jaZHxv43Qm1WtLIPutUk6y8bSyRFUQByOSNgRRiLZQVL2VoyMpRyyHNHZMq4coBQejR1joEa0q2PaXOajOUYUDBn6XkWQ+pgsLqrTIogciiKB1onYTWjNEE9nffILajVGhzVaCKdDZrCVffjstCRD8krnA4cKNCdqQF6nqF+Z60O267sgkGmP4kz/5E37zN3+TZ555hs9//vM8++yz/OEf/iF/+7d/u3zanwGnRORF4L8DvnS/5++4cWMTw+WIJJI2EANdU+O0QrqatLGTF4B1+P4SS1vnwGU81psSMZq2mOR5NBZtFN3kNMGWeFthkmc+eZTWDmn1gMrvczB5DCFiYs129y6dHVF2+1TdPsaQdySxw6aW4CoQlZVvWtFW27TFGB09i50nMke4XTCYX6EdrxVHyWtZKwhJ6KJFlFlh+CJ5vn0yiDL98w/Py43wwoM8r+8n6MYY2d3d5eLFi3f9mqNKtEMM9rB/2QkhhjXGQ27RE1hJfZcS4LRs37OUAsshZbT37f3IRz7CpUuXbunbu+Rf369M976zuI/dhkZP5ypMW9N6T1lUWZ0mAtUQvCf21KGkBWkj+ETs1UbJQGprtNYkJcRiQFrMe8aBpitHqLYBAQ0clOcou32URAZpznuDJ9ho3sXFOaj8foWvcaph356ibPeIGMQURO+AgJbIYnSe2OyjU0eyhung/OqaWDKdlqynEHNRzUhCCISQ8nMDDMs8WetB97g752c/+1k++9nPHvnbH/3RH61+TynVwH99H6frrsdx85qCJ1Rj1O47SAxoJSAme5lunUXqGcGnzOEVgcEGcd6QUCSlacThuj2M1iSlEITgBhAiSRRKMjVMd/MsnKBjb3iRqt1FpURJy9xtMumu4dqWebGDqvcgaiyehRni/KJXQRqiDCB6FJFm+yJ6vovuv0NIPdNCcsDVKgdZyLiuiEZLIsWwUpQW7rAbwu2Uhg/qvL4feOHg4OCOXrm3e1/6LJSY51rWil93fcxVBrsGI6wyXRBNZjMsfXRjnt8bjz8ajfjkJz/JO++8w3e+8x0ef/xxzpw5c6Tecj/hhfsedJf2dkdGjGAs+6ZiqLtDEr1SRG1yhRtZUb9SUWWfXRIpCQmFMnZFPxIN3pZIyGYmRkFrK5RvST11bEHG9EAwRHaL8wzCPoZIW0yQZo8iTNlJC64VFxjW7xFTR2NGJJ8dizSRutrCdXMUgcVwSfyWvjKqgJhZCykRYqJLIKIpjUIkX0jOHJ/p3k6f/qCNY7Oi4EnRs0/BWIUcXLUFndvy6GJIqLssghBFQkD328H+buXtEEuTC5Z9dhxSyHOtFEppujTI7BYRdBLmbgsXmtUls6/OUMY5pT9gVm4znL2JJIONDTMzwfk5SluCLUldXoBKEt34FGkxox6eWVHVIDMXMrbbG6ikRIrQJkGLQatAShGrDxfl+rw+LDLge2Uv7O7uAlkiftL3W47Ut+5KKYEsWQx3f6wUY/bi6D0bUozI0t5xiQ9HRVLLv0XSbTLppW/vzs4OL730Eu+88w5PP/00g8Hg4YMXUgy55TkCpkCPtnpLxrxiktLEYpD9FdLSEzP1NLCAip4UI6o3vlYx98oyKhKVQaeASgGrAkHbFa5ndaLTJVGyb642moXdoNED0JrZ4CxTu02nSra6yyzKHSq/x7i9grEKFVt0yvSxzg0JyjEbnDvyXX0SFl7TBoP0CK4xYHRmn4akEaWx9s7wwoM+jsuKUuiIvsNVJbJxJu9eVJYDYwyhKPMORtbmu+gtF5eFFF0QTebvkiJKEsmVsGy/AmAdUTKDAKURa2lNhVeOqByhGLGwGyzMGCsde5OfIaIwoWbirxG1w3ZTinY/u9f1xtk6Bnw1zq3dWacQCG2QLDNPmvWmAxEIUaOUxR4DGz1MMuB7cRlbCiHG4/E9QxMAalXwCjfYO54k8vYvWTIgYlgzuiHvuJa47zITvsPxl769TzzxxMq3N4SwCrp3Uhd+5Stf4aMf/Sgi8j0R+QcReXz5mIgEEfnnD4Sne2Qygs8qrbalHFQEW2Yjm9UVnkgidMr17IbMcHAq4HWBDg0Oj/JtJtdHjwotNrYUOmZ1UWxwqaHSHUk0NrUYOqxOeZtKBtDFGrx2BLGIEhblFgszYWE2qFiwO3wMlTyT5jLWGkxYUIQ5VZhSl1t4XbC+NEOAEBIxQRc1KIMWlT0jWAom1IpcH2Nc6dLv53blpzFuRRkLIaKtpdMOigFolTPWPkB6Ux6hBGlJPYTQYiSik88MD2tRMaBiyJhsMUTFDp0yRptcmf0z6JWKtiCJ6g1vFMEN6XRJpyusePZHj1HbDbxyFLQEXeLaAwbzy6SizHaesc3MGe2OLMXMSoEuCItO6ILBGI3VglGCUkIScP3NdJ0K+LAYGcG9ZbrvvPMOo9Honr14D83L+7W+lAGvrpG7PdAyy+0Ddcy+HmlpE7nGAT6C6d7l8dd9e69fv85sNkNrfUd14Sc/+Um+/e1vk1L6OFno8j+tPbxIKX3ig1ekBY+PCVEGrQ2o7Oq/0kH3qb8rslMVoe8UEVoKaWjFYlKDji0mzAnVBBXyYnRhzvL6LuOMQZwytE22YIxzBnGGs2T2QWqxqc0siD6v0QKNm9CqkkYPMBK4Pnyc2kxwYU50Q0yYU3V7oIvVNbH8MRqcAbPEAAV8ymEBEULMz1mOh3UbCscv0Jgy3U+0RbTJLABlcmbbD+0s0VV9RpPl146G1gxxdNjU5LY+KWblWWixoWYQpnTlJBvWxIZBTxUzMc9jmeYEW6FSFlJoiXR2QEQTlEXryLw8RWtHOfAXjkW5jaTIcH6ZVI4w3Yxgc3+wZfFzWX9RCqwCq/PuJaRcQMtZOpiekQJ5Xpc304dpXk9aSAsh8PLLL/PUU0/dO5bb/19iWKOMrWegd/l51ni4K+gghsN/xx5mWOf/npALvPTtHY/H/PVf/zXf+MY3ePTRR2+rLvz1X//19Z5z/wjcVGn8QOCF9S1L6FrqpqWs8rYyQd7yF8N8wkNejEYEnyDpPuMFAgpVltR2k05VdFKhiNTjs3SqoFUVIHTliLka48WiCVgLHZYizZnE6zgLGk8V54zjHtGV6Niik8dJh7eDLN1VDiWJA3eKhRmjSMwHZ+nEsnCTzN9cm7OYhJh03/32kB7YBZg3KmdIa5SihxleuHEr2tYLuhAxtkBUzjiT1vhimBcAOcPQ0rMcXJWNj0KLDjVjNWdhN9Cxza3Vo0cpwRuHEFDJM/a7zMstXKxxYcGGv0JTblKEGUWYs5Gu07khNtaY1FDR4G2Vpca9lLgzo5WKLRYD5oMdWjvCdlO64SmaYtxnQ4dzG1IPDenDm2kuqQldUHRJH6GKPaw305Nmuq+99hrnz5+nKA4l0/c60nqGu2IbnPB464o2kSwDXvVLS7AefFdCjJN/VqUUn//859nZ2TniFHgLdeH6+NfA3639uxSRb3/g7IW33nmHLVdk5Q/0XzplClgxgPk+maCeT1woBmitCW1H22/rgi7xbYsiYnovhoXbQC9lqKJoiwld16B760dfluy3jkJqLC2NrUjdAWWcUqSavWKHsr1OigarOxZmiPUL6JVOjYywqcnvNTzHdXeWlGK/de5z5Zz0ZL5uAqez5ttHMD1IaG+xOB8meOE4ytgrL7/M+WKIaJ23+P0NFaWJxRBVTzOcQILgCTGgywky28WTWSlOPHvFOQp/gNWAgqAMLQ6bPIiipGW3PMeg20dEGMV99srzbNZvItFzKr3LteIsm83bROVwqmVmRhRhCmKIxhCCzTiuysY1nTKk1KFToB6cxoeI6Vs/AWjJTw1JEyJoFVES8f1uGFhBRnBn9sKDOk6C6bZty1tvvcWv/MqvAPdehDuEF9YhhXXvhbvNdPvP3W9R8k1zuVWJpKQQnQ6DeTrh8W/4zCEELly4wNbW1pHHbpXxi8h/A/wi8C/X/vxYSumt+xp0ReTIlqWua/YOpmyfPg1d3yGWpcVaogkRV46hnuJTQptsyxeKIfXsGlhLGzVaC94NUF1DSgmjIkpDywATOyJZHdSavP3sNzHEwuG9w+BRkliUp/DdAptqJvE6B26DcXMZQVGohj2zTdXtZmWTdoTQF+ZEmA/O5WPGtNo9xyj4CCGmHgcUlChKk9Aqn4Nybf09rBkRHF1ks9mM+XwGZ0+BnyMp5UJpgkTM8udiiMyuZy5zCBk7JbFPgUXn7bhkP9152qCSGquyaUm0BZ1vUZJpgzrC1G1T9GyUgo6r1aOMuusIiXHaY688z1b9ZvbW1Q0HZpOq3SMZS6cLkicr5ZQiuhLvVaaOVTuIaHyMOSbr5fc4TMBaL6SksTpR2EgKULr/MoLu3QbOF198kSeffHLlFX0vQXcVoFLKW+xV4OUwIMaUeZ93M+IapiscZr6xr7BFdZjx3qupDqx4upubm3ejLuSb3/wmwH8P/MuUUrN2nLfgA4YXLl26xLmzZwmmJLgh+aRmEnMMHkRoRcNgg4Csemu1IZKqAVEMsecjKKXwbpAVQT0mq5Si08UqQzEKOp1xvYjqKUkDWilopSSJZmEnzPSEucqV7t3iPB0GHVt2wts0dkIZDqjCDKezIYtXFq+rXCDr09sQE61f4nsJq3v8T+dyj48Z1zX6+MX5MMMLL7zwAk889li207TDDC2wrBrn+e1CIAw2cwA2FowjiEIXBQs9IoohSC/dtYY5AxBNFNXj/iVBTJ5LZVBG0+gBXixeHFYl9u0pWjWgUUOcdFwtH6NRAwKGcdyjsWOK3h3OmoRKoa8N5KJsUI6uGKEE9LLJacxeGl3M6qbQJ8hGgyghxEx1LNem7mGd17sNnNPplIODA86dO2TvvC+znBR7Bkm84Scf746y3CVUsIwnS34vy410/ncMh6blK6z3Hj5zjJEQAo899tgd1YXPPfccv/d7vwfwuZTS5dV3FtkSkQI+QMrY3t4edV0zGuZg2+oim43H0LdkF0Sb7BxlHW3SSM/lXNQ1w9EYb7OJRgggEjES8W6Qs80UM36rwUvut6UJlMrTmTKH6pTya0xFEkVEIQq8GdBISSsVWsF+cY6Z2WChRozSHvvFWcpwwMhfZyAL5sX2Ckrov2S+YXjPoo2EqHpJaF6gkO+/Wh3dejys8AIczuuVK1fQWjMcDrJxo7Z0xYj+qiaF/oYKBISZ6oUwSjNvWspBbt2zSI7UK7xEegcx0ZCkx2TJTJf+FAqgjCEoQ+x5DEZDbYY5EKsCoyL77jSNHlLrIUY8++VZSJGy28eo/Eob5jg/pSszbr/kiy0/SxcS00Vk4TNsYo1gVML02K5SoG9xM72ffM4PetytOOJHP/rRTUKI9wMvKN8eYrrr2Wla1gJOVkxb+TjAEZpYfmyZTd9YsDvZZw4hUBTFHdWFX/ziF5lOpwBfE5F/FpGl7PAZ4Nsi8t0PBNONMfLCCy/w0Y9+lOTr1QdfKEdZTJB6P/dH602vEbVyfaoXcwqXO0loyVzbIszQ/bky0jFTEyb+Sr+l1WijqJOlinMSGiMtB2bIyO/mfyvPQlU4P4eU8bjOlBCa1fvUagPjazSBQrqVis3GBV5XxLS6jwL5GJUzhG7GoovIIGfhIhn+CDFnvjdO3sMqjljO66VLl/jEJz6R51WAlAgoYjHGza9nX1OlV4FW2YLgCsJiijEWrTVKQTAlKWVZtkJyaxxdoEIWoqQkaJVobIVtZiA9bqcNqTcpTyhEC14cJvleGAO1jHDUOUASOah6hWLyoCwxJVw3JY4ezdT6ZdyVPMdaa2yKtPUcVTq8cnnXIglF+i9mXu8GXljeZG/EMuHkhTQRgRjRsclufOu47lLOe1dH6uGDPtOVlIjdkve7FsDXvBgO/36ij5zfLR22YbqTurCHFgA+ccMx/hPwc/ABGd7M53NGo1EmUC8rhilLKOfKEIdbiM7GISvivFK0uqBpW4oiMxg0nsp0NHqIji02NbhUM9H7TPU4c3FpcNSMTM1cBpTMKVlwWl1jYSYMWFCxYFP2CKbE0eBoGEhu2a4ysIFRmXLUKUfXm+DslueYmwlTu3OIx69OYs5qR4MKV5TMFjWLxrNohYNa03lFccMt7WHdhkKe17qu2dnZoaqqvtVKfixnAonGTRCbvW5FLVVouTh20ITMYOl3H0blXngJwdBhaFGhA2tJCJYOmzoGaU7rhtiUu3yULDAmG847WiwtTkeC6B5UihgNXhW93NiitFC73JQ0GUMoBiyKbRo36WE+6ZkoQGZYU5WG0XCA7zzT2ZzOJxad4qBRmGN2MOuUsYdlXu+U6aaUuHTpEh/+8IePfe09vWdoUD73LDzKKOgD790ExVXBLB3++7hi3BLL7RkMqRfFnHSklO5rDea+B92UEvv7+ytT46xV77tykhdvq1zP6ez3azlnpWlqzHgzL9bgcdJiUsvILNiTzYyVisVjsSqyZ3dopKShzBVvk3hPnaWRghbHWM24pk8DEUvLKbmKt8MspEgzNtIuyZYYWkzqKGiyVFSyBaSVSG032XM7wCF1aPl7F4R5Z/AUVOWAFD2hqzHKY3SiuiHheVhJ9JA/b9u2Kxu/uPIgyBd2jJEgKlOwbAFrjIamaShHY5IbkJYKQjqstCij8FgcTc+l7lCFoROHSh0az0QOmJsJJrW41DDkAOciCaFKc6o0Z6A7otLY1B9HJ2LvYwyS2/WoiiCOpCzJliyK7VUNJ4vN+yHQeEUbDUU1xFrLovF03mNUorph2tbn9WGCje6U6b755ptsb2+v805X414LacZ32TxznbmQjma8dzzqjcF2CS8sJzOlFVd3lemmw+TvXsYDbe341ltvUVXVaou1/PIxJUR6tZJIVoaZMr+ozwBTCFilacTkhYvQJtsHVJjabVoKOgoWwaEVzM0GHZYORycFWiv2ZIuakpoSqwLX9DmmjJgzwEnH1G7SisXSspWugHGY1FIH6Nz3AAAgAElEQVSlOeN4QNK5E8Wy2r2Q0Q0y0Tx3XRRaL72JucLYisJZ6tkB9WKG5qhj0XpG9LAF3Zdffhnn3GEWt1T7xEgMEVFZGYbSNDY3EIV8znzX4ZzFx0R0g36H0qLxCBGxmj3ZppGCJtqcr7qCqd6glYKGEqs8e8VZaqloyddNMoaZjNB4SuaM1ZRWFZRxRhVnFDpDDjp1GDzaKqIyKyXbzG4SU+4UoQQy0TPPrY9C44VprehSgbMFhIb5dJfQ7h85Nw8rK+V2gdN7z6uvvsqTTz554tfecsSIDi0q9r3KbuwacSLM9bCARorgwyqQ50aUS1ZE/j2tO5ndw7ifO5j7GnTruubq1atH7oxLU2GB3E+sz4BA6JTNW74Y0ZJwRhNjZgy04ujcBm2ydNEQMCQUrRnjxdAl02OokqvamCwQlUxcnzHog3HurzVTExZU1JSgFHOzyZ5ssZAhlpbWDIkoyjRjO77XB+KGVlVLJ7je1eFwWJ1wNlKY7PWgFYgyVKNttFI899x3eO+99w7PxUO6OGezGbu7u0c+b7V1BmXsKstTazdUEFpdkowlxUDhbNbF+46u7WjdBotY0KaCJjqiWERrpjJmES0BQ8SAsdRqQIfBi0OpxMxsUve7myA5Y72uTrFgSCsFTgUOzDY6dVmlKHOishRxgQsLjMrScK9cbhkPKzVaSod0sZ42jjMJZxJGQ1EOGY42+MnLl7h06dLKBvBhhY1ux9N95ZVXePTRR295jd5TptsuEN9y6eVuJWQ4ylxYp48dP1bCh7XnJenNy/siXFrDilcBN61DGScf9xOrv69B99KlSzz++ONHJqPaPN1jfGoNTug3ESnRJWGuB4QIojTKWFRvxZeMZZEG+JjLLSHmTgzLwlboqyBGk6WeZMmvCFgrdJKz5bRUJ+mKrg/OKIXXFTMZU8sAUYraTdjXO7RYRnEPrGOuJ0e+YyZhZ/VS5xUxCEpS31erl4tG2JgM+MQnPsHly5f5/ve/T9M0Dy2f84UXXrip06sozejMI5TjrbW5PbofmEfNImYubgzZ+EgZizbCVE1oKOiSwfe0MNGOA1/2N7e+y4exdBhibwyvtdDqAZ4MM3nJwXkmI1pKOlWitHDdnqWRioCmkIbajHBhThkOKKWldWPWty/LNRyB1iu6mEUyVieWRIWYhKpQfPKTn2Q4HPKd7+Sb6sPKSrkVvFDXNe+9995tvXJPiunGGBi//s+0+x0vve559a2OlQH5DZnu7WJ5SumQnkjq/RsghVxQOzS/WXJzYSmkSEua2T2M+7le71vQTSkxGAzY2dk5MpG2GjA59yhuOOn9SeWQS9dDD10I1G6IKqqe0ZDpY8YqktE0ZNlhhn9zEabTJTEldFbbU+rctkURsNLhxFPaQNsXxTQBp7retKb/fAJR2ZxVY4li8LrgwGwxV2MgwxdrX7Kvcudyt1Kpx3YVs1ZRd5plJby0Cecczz77LBcuXOC73/3uyhIPHq6g+9GPfvTY6rWIMNg+zfDUWZQ2R8jvKUW6tqUYT2jdCGXcirGijc43OSnyDiVmK0UExDjaZFni/IoIxhJEL0Nx7gysy0OQXYSksz+vF7MyNJqZDVpV0aoSLYm94mzeCcU2Q1vHrL9cVM12oZBho9orfFCQoDQ5wF64cGF1U106UcHDtYO5Vbb64x//mKeffnoFhZ3ktbccP/k+EjrGYZ/KeF56LfLOe3NiWHcGOyyk3f7Ya5juErPvd9SrppRHpL9rQT3ee9B94OAFEeGpp57KRuM3nDClFMOtHQabOzkrWpKXY8gFmQQimkaXYMq8eEX6xDhhnKJJDi0BSZnVMClavK6y2xMdBS2bZt73V0tUqqFSNVt2zkJVlFJT0jBRc5IpV8UcJ11vcK3z9lKySGOhh7RSsqu2CUHwsW80ufy+AD3213qh6TK223QKHxUDe3gOTp06xac+9Sm6ruMnP/kJ02luy36ri/ratWt85jOf4emnn+Yzn/kM169fv9U5Dz0XcJ0PeN/HcYWU9eGqIaOdcyhjVwE3eL/iNkfRtG6UjXF6eCkmsvrQFrRB9czbiFERtMYr1zuKBZwEjOlN4ukw4ilVS6eLLHjorT2VybuYBIgolNa0ZoAXR6cKlIKpPUWjhyzspMdus6NYSrKSdmvJCzTGXCytO2HeCvNO4dbi6fKmur29zeXLl3njjTduuzgftHk9LnDu7e3RNA07Ozt3fP1Jgm7afQdEM5CGuk5IEv7xuRl//x/e44c/Psgwx9rxbnXoQ6LDWjBVQupdxtahh7Ru+7jOcLiH8UCzF25HQ3HVgMnOeWxZ9eoQaDuPc0V2rBJFp23uwtsvXquyKKJwgYUe5kVIS6k7Jq5GrGVB9l9NQCkNQTumsST7swa2zT77soGTlkpqNtUuxqqckUrNkEX2TRCdCy4EtIJaV0zJGa+S/mRJ/k9MwrzVeA9OJyoXc3ZrEkYnhsXRydVas729zYULF/jmN7+JiFDX9bHn6ctf/jKf/vSnuXTpEp/+9KeP9e3sxyKl9In+56bGWz/NobRhvHOOYjghhoD3Hq1NFrL0lMDOVKsCm1Y5uBkCqsgQwpIiaCVSmEijKiwdhXSU0jI0HY2qKGkopWZDT1dNTAtaSmlwJuVsNuV5NELGbxGS5NZJjR0xt5MVhpuRkdRzgXN2O+8UIUj+LDpS9HM7Lm5etKPRiAsXLnDt2jV+8IMf8Morrxx7jh60eb0RIlh65f7sz/7sHeGDk2S66eqb4FtiynanW6cHpNCxaD1NHfnn/2+fr/3by7zy+pyVKfktD5bWHlwL0r04Yqk8O2QxHP6sCm8nHCLycJmY3/S4Uoy2TjPeOUtIoFTfQ2x1CyPjrrqEmChMwKoOpzwjUzPVY6a+pPaWeWfxIRPmr8cJdXTUqcjyUu24GrdYhJJ5HFDqwFW1wzQNaHEY8SgrLKSiYMGIAyZmRqccZVpQpJqgSrTqYYTVluZwlxJjxnDbIMQovVop4XREH3NmlxDMb/3Wb3FwcMAf/MEfHHuOvv71r/OFL3wBgC984Qv8zd/8zfuYkZ/uqCabeF3RxYQ2fd+4pQUi2Tc5aovTESOhz1o7ChuYMqBQPu9oiJS640BtEHo2dQRK3XFdcscCRWQkM8RmiXHJgiEzRqamUw6XGiwNherw2h4eRSm8HqBUWrmI5dEXw7zQdkIdhCao3DaKjO+W9uZrO8aI1pqPf/zjnD17lr/4i784dg086PN6+fJlBoMB4/H4js89SdDtXn0BHyD0a2dsO5pW46zBd12WjbeBf/Pv3uPr/88V2u42uG6CJXNhuRiXcOV68YxwIzvi3oto8BBkunczGco4Xn7zHYYbGz2ckP+eYiLGSBsjtSrooiZGoQ2GJuQGgXMq9nxFHS1NyFtKZTTTNMQnjU+Z7aCM4SCNMkEp5bboczViGocsUkmHQ5TmspymJnc5mOgpUz2hYk6dyqMmRSwRpISShNP5R/eQpI/CvFU3yX+XY1lwMcYwGo340z/902Of9+6773L+/HkAzp8/z+XLl499Hr1VnIj8o4j8qzue9J/CiDHy0k9+ws4jT1COJn3RIz+WyG2N2qQItsSIx6mASJZSlybyZrPFQVvQRUMbDVrBgYypY0GbHG1yOJW4JtssUsUiVZm/rUuus0lHNsgf6TkzNaZMC8o0Z8SUTleY1NKJuwnuW7/pa5Uz28JkbFdJIiRB3yL7W6cCFkXBV77ylWMzxQd5XmOMvPTSSzz11FN39fy7XecpeNrda9kqocftd4YdO5uaEDTOFYSQIHVsTRTvXWn40//jTV5/++ZdYIxrHN5l5rNsSLlGYVz1TAvxKDVtVYA7+bifQfcD6ZF2N3run/zkJzzyyEU2tk/T1gv29vZW1cUYcoVSesxv9yAxtB0+KpRWtCEixjJvFANatMlZlDJCHatsjE3WFmkDdchtv+m3N1FbmqgxROgxvL20ScUCIVHowFU5xzSNMi6ZyD28+kJa7EuCkBDJpPouCL5nVByXDcFREv1LL73Exz/+8Zue88d//McnOd2PpZTeEpEngX8vIt9PKb10kgPc7/HGG29w+vRpqqqCquL1N9+mLMmVajJkFGPEatiNQ0wIOBWISdFFcFbYaweoOMcqsshCCS1V7jLRw0hahFkaYpNHZOm3CHtpg4oaRcLpwFV1lnHYzXUA9piZEV4Vq+w29XWYkIS+MXTm7vY3VqVy0tQFoRwdf12vsxe+9a1v8Ru/8Rs3bUUf9Hl97bXXOHv2LGVZ3vVr7iboXvnh84wIpKW/BcLIdtRNwhqotKBcgbeOadvRikdc5H//N+/y6X+xwa/+4tECbhZaHd15EtIhXLvKdvPDK5w3RlK492z3gW5MeTdUkqZpuHz58sqb05UV7+1N2dreoVlMQRS6l5EaC2ITe52mVD7L/aMgCkxhOFjAoGhAckDUJtCGgjIuEEloMn2sDiVlWhxissbgQ8CQecFGYB6HOFoUOds5iJv55iiy4m0uf0h5oS5ahY/5rj8sIlWRGBW3XpxLms6HPvQhnnvuuWPP19mzZ3n77bc5f/48b7/9NmfOnDnmaLC0ikspvSwi/xH4JPCfLeh673n99df55V/+5dXfQgJVTbAE5rMDYFnkEpSGJmgWTWRgA3WX0DobB81DwUh3qJ7xIpLwYpHg0fmWjFbQUaB732MRlbH4WOGkA7IPxkw2cWGeueB0XLUTkKO7T61ykE19AbdNQteqVTPZyiWG7vgVux50P/7xj/O1r32N06dP3/S8B21el5+5bVvefPPN1Xo8yWvvNNS1Nw7Lz5Kd3CoanFJcnybms5bBRNEibG+NuNYmdhcN+1PN1/7tZV7+yZzf+VfnMEYf7kpWYyn9DSue7mEGnHJvxrQmlODkWe7yxvLAiiPudiKW3pzr1fuUMh64cfo8xrq8MEVwRvABlFG0qsCHHBC1RKwKDCtoVIWWiNOeQnnGtiEamwtrqqVULRt2gdcFRjyF5KJLYSKdWDS5LbdTgU4V2cUqafaZ4EPvoSv9T09bygWXXNmOKeN9MQldECblnTOi252vz33uc3z1q18F4Ktf/Sq//du/fdy5XlnFicgO8C+A52964n0YdzuvS0L9jReniDDaPs3GqbMY61A6m5ijhJgUUhjm0a6I77kTsCbqgoDKBTdJWIkoo/tW9wHTzzk6F8qUZIav1tBQkHpOBAK1HtFKQScFCzUihsxciIkVz7rf/RJS9tCtOyGkLJAQgdFdzOvtSPQP2rwux0svvcQTTzyx8sq9m3E38EJz7TJVnLJML0XyDrFUHcFHnE2c2c7du53OrnwLX1ANKooi4Gzih5fm/A//yytcu96s9ZVcy3KPMBRYXUMrDnBvdJN6J7OTWkYs5/aBxnTvNKbTKdPplLNnzx75+/KiLcqKrdPnKKoBSBZDaJ0zEWMSwTjqZClNoLKBUeEZ2oZoHG3UGPEY8QxNi3bCQRz0f+vYtFPQFo+iUjVDtWDLzmioKKgppGWoaqJyzCn7Vtz9glzNZaaPhQQmJcZlYFRki0mtEs7kvmnHjRuD7q3Gl770Jb7xjW/w9NNP841vfIMvfelLy3P0iyLyv/VPW1nFAf8B+HJK6QNdnHDrLeWtCPXri7MYDNk4fQ5XVCBCYSVnIjEhRpjHAmFZiExYFdFG0WKwyuNULroNnWchBYVqKaVloBY4Ax6DkxZLR6U7vCp6F7NMRQva4ZWhVoOeBczqv+s0zqYVhMTYBcYuUJiM3d9Npns7/vWDOK8hBPb29o41477duF3QXaKL9WuXjniVpN6LQ0SwhSGGxPTA0zaBsoC2C5zbsbjCMdnYYH+uaLqG1kf+1//zLb7/w70eukwr8UOSQ26uLP++fGyJ764A/GV79rsfy7l9oOGFO40f//jHN3lzwtFJFKUYbW7TLubMDvZwOtPLlBa0igwcvH2t4MKoIabsZIWQGQtdwVDX+e+S+yS+67cZqdzhQPrnXQkVG2oGJDbslGkYMeIAS6BULa+lR+gL3WtCKzlyo/VJwPftXRSoBKUJt/zudxt0T506xT/8wz8c9/pvA/9t//vKKu6nNZZzdNx3ePHFF/nQhz50E/f4xsWptWG8fZrFdJ8YD9if+hVDZHOUaDoHdGy4NivBBIwTDtoBY5lnaleCsWvZbUdMZIaVgJGA08K+rzjFLgmFk4aFDLBxke0iUdR6wDLUrqhiHEJ9y+AbotAE0Ck/d1KFW2ZJNwbdW21DH8R5bZqGZ5999sQKs1tRQ9+6Bt99GX7tyWvY+XXSsv7RF8uXv5vBgOlbV3mkCixi4Mq1FruTWMwDe/NIObRcfGSC72ouX55SN5F/9x92efHlA37150subq4lACsVWi/7zdhfb6ihDh+HExfS1jPd+wUv/FSD7rVr1xCRW6qbbrxzumqAKUrevvIuQ1eDEkIQWg+jgXDVD6HtGBUeaxQ+KZQRDsIQG3P/NJHs+j+NQ2xsUCr/TenEtTBhIPXK7HzGBImegTTMU0UumS2DSE53lxeNAMbkIlpMQudh6hXbo/cfdB/UsSyS3hhYDw4OmM/nx2KUt8qIqtEE40revPw2gyKs2hs5AyEaXt+3XBgt0DpDEEbDQRyhQnbZSKKwmlzsDJ5CcieSUkWupVMM0xRNoJIFXmtCTFTUHLCUdacjJkbrGZk1kMKatDvKLXcvcHReQwgn2qb/5xxXr14FYHt7+8SvvdW8vvpu4vIuzF97kTImVJ/o5MRILZcRgyJyeqcg7R9gdOTMhmLuIBg4s2N49Z2INfDedTh3bovFYo7ojlffCsz25jy6GfjVZzWF0BvcrFk7hmUnCemZYmsUpBOODwJe+KkF3aU358c+9rFjH7/VJCqlKEYb/Md/Svz8hw4bBC4DatSO/VrYHGWT6/waaFKBSW1utyS5bU5HgcQOo/L7aa2YxQqXur6DgJC0Yjc69tOYpQgiZZIDWkuf7eTPubyg2qDpQi7sTKpbT+zDHnRvJxs9bvdyu9cAaGN48e2KgWv50IUW7yHbhCuKQnG1qdiquly07Pm+QdncsLTPWEQgacdBZyjEIyp7YcwYo1PH/8/du8dYll1lnr+9z+O+b9x4R2TkOysrq7KqXI/MdEFD08Y0YEM3Nhi3BgaMZaqxMGDaSCONEBIt9R89I400arXdBUYWWAiPaUvTCBhhng0YbMqVVWVXpTOr8hmPjHfEfd97nnvv+WPfezMyKx8RWZFZmSwppaqIG+fcc9bZ66z9rW99y8MyHoSEpikTy/zg7+yO035nxzFbXq/a4rzY3UyciltCC3A9KwW4bfvsg2S5XG5HbIWtdiu/bjbgubF5/DRAGZuyiC1/07esSHFcFykNKk5p1SKUSvHHBZvthJHhDElgGBu2jVJhmqXiC4TqIoRmvZrw53/XYN84PDHTL56xhTYGdk4a10b23ND1th17qOGFlZUVSqUShULhpr+/lRONMeybcqk1JH/7bY/JoYCD0wa31xzvOIDrEhvwSAZbQMc1pMa3YzZkAgikC9q4pIkm46QgwHcg1T5SJ70GUktLayUFbNCl149/bSsKdihloyNRRuA7hnxGkfWgkrtzpnvjIn1Y7GY+2tzcxHEcKpXKtv8G7L3QWrN30uN/flPxT2cc3veMoVyypUrpCISRxCKD1LapweKBEseFKHFsC7exe1bXc4hSB9/EIOx0Co1HqB1cY1uSpYRuT6azX+DWxnbHDajVxgoZNUJJqqxQku9oytvw68Nm+Xx+wKbZre8/nKkz5VYxaS/YGoPp0/MGVEsoezGL+GR9QTdUDFUEXd+wUYvxMj6trmZxJWZ63KXTVezfmwWjKGcL1DYaVNyINEq50FIsnW9wZDTG2dIUYXq8YGMYaDDcTTfaQ1tI01pz+fJljhw5ctvP3eym9APUI/tcNqoxf/VNw9de94gTW3W2koq2Epo6fi8IKjJOSt5LyGc1ocmSdWxxpeDGlHKKiCwZmZCRCXk3xvEcjHBwUba5wjhgrOSkK81gUfaLaf0Xa86z7b9WT0C8rf33xuvbbQfeT7uRg327yQJ3Mt1bBO95rEiaxsxdjfl//05wZdnpkeXpqcqB8RwSXFxpcIQdO5p1FanwoTeFwpOKrK97Lb8KKazvHEeQCB+wnWWRyA7wW9nzrSMN12Ku1dFNlSDjGnKexvdgKHf7CQsPS3Z7o+1kIvBW2/oyVRrOL8L8apv9xU0EyiYrAvrYgqVaXgvsHgmea2fSlfISo6zPxocdshlbZD2036fR1mQyLqsbMVrbIDo1nqVUyJCkCe1uzNzVkNfORFy4kpD2KSlmazHt2tw0s82R833rw2kPXdCdn59namqKTCZzy8/c7E3bz4aEEHzviSJLV1tEYcKFefjK33osbkiynqaYNXiOopBJyOYELZWxi1NYOKKUiWjqPImWOL2iy3AmICCHRJOTEUUnpOAnVkjb2OCtjBy0Ll7LjOzD5khDJafI+7YjzQA5//YO7TvwYVIY22o3Zq3Ly8sMDQ3dVhDnZpmu6bVqCiHwfcmhaUG3HdLsGP78m5Kvn8ugNGQ8Cza40uD7EAmrEJdxErJuSikT4/oOsfHJyoScjCl7IY7roIzEKjqkZFxltZut0oOF/RSDRbx1rJYxhqynGcql5H3Losh6Vj70VvawZrpCiFsWxLbzt32/Xlo2VFsBcdDBQQ3WCDAQEYIeit57FHxifNfCSRlfopUhjRXLqyG1eorrGjZripGyQy4rGal4FHKCWiNFa0OzpRkfySGkYKiQ0O2mrKwZ/urv19moRj1YgeupY3fRGdH37QMp7Qg3D5xJkrC4uMjBgwfv+Lc3Ls7+wyCEoFTyOH6wA1qj04Qw0Pz1t7P8+at52r2tYJw6JMrB8wTVpEQrzhCmHqHyLGmeHBtRkW7qE2gfVxi65KkmRRJjKfdlP6Bl7ARj5xruP2h2gd7PDISJIIghiEGlhoJ/6y0oXJ/pPizFFrjm1+uyG6W4cuXKHXcvt/Lr1kB18omAyVGDUAmO0MytSP7o6zkWq+6Ak+1ITdZL0a5LI83Zl6K23vE9RTUt2bHpgC8Ssl5KB9skkRERJScgEjmMsd/pukkRXKuzGNNXixNEKUSpIHMbRgpc8+vdZIzvtt3t9xbC3v9/uijYaKV4jh3G2tebBt5evOpVLg020223U3xfoI2hkLfF0skxj1JBUqunZD1Bva24uprguZJuZJietENrh4c8qvUEbVy0dhAkuFITx5pXv93k29+po9L0Wta7te97B7Y16D6QzRE3s8uXL3PgwIE7Bpkbnb81ywUrOfev3msYKmqSJLVbh1QzuyL4w38ocXHZI1GSWAtS7SB628p24pFoh1Tb7AfHpa1zxMolMXZwO45LPS0SqAyBytDVWUsDE9fe0te2SNcI1kpbScdOJGiFkvytE/nBNf1zgRfm5+eZnp6+o5r+nfwaxzEbGxv8+q8cxuiUbjui1YyoNVL+5o0Cf/laliB1SZRDrByUsXq89bRAJ7XaG7F2cRxD2xRopjlC7RNpH09CkzKBzpAaQWS8AU1M9Hzbz3T7GZkQdtKz6TW6dCPxtploN9p2m14eRNtu2/6NJoSgkZRIlKCVZKlFJWbbU7zRPcpCOm2Db6+bwXYL2qwaAwKBR0whK2i2wZPgSWOL3YlCYJgY8fA8QTHvcnhvhkbLwhFrG7Gdtm40lZJDseCg4pSM71GtK1Qc0e0mrKzF/ONLNRrNuBdoDXcj7bh1zT6QkyO2mjGGIAioVqvMzMzc8fM3Ls6tWS7QE+M4wi/8uwnQKVGYEIUJYVcRJ4Kvn81wpVYmUdfaBQ0gPJfI+INbLQS4riAWPqmxRRttpG09NTki7dJUedvSrSFJ7Fb02oUxeFvaqbZWGCXnG4YLt39478VW5X5a30dxHLO0tMSBAwe2/Td9u9GvV65c4cCBA0yM5vjR95UxKrENDcKgEsXZOZ/FRpFq1ydVEqVt8VJKO6Q00j5KS9vZJgRaunR01gof4QCCRGRp6zztNNtzn9XISFOrpWsDbh/XtX1sAo1O7Yt3KL89vz6M9k4y3UZaIVG2RVtp01Pdc5hN93ImedTe137AE2CkHGS6jra7mmJBkKYaYTTlosXzldbMLgXUGjGehEZLMzbs47uGSsnBcw3VRoIxho3NmKxvJTz3jPsY45ImKa1mxGY14Zuv1jl/qdXTXdg5beyBhxf61nfkhQsXeOSRR7b1QG51/o3ZULVaxXVdyuUyTz4+xOE9DjqNMVpZWT0J3UBTDzK8vjxMM/KR0k4A8KQm42kS6WOEHbXuCIXvKjuRwEicXvuo52hikSXFQ2tIlU2BBg0SPVPa8nLrXbsVdYQh4+htL86HaY7WVuv76PLlyxw8uL220a2+v9GvYRhSr9eZmpoC4CM/MsX0mKTbiei2I7qdmDiBRtuw3MxztVEkNbJ3XAv/OK4gxqM/wU4CngOJ8K41PGAbbiJp6VFKm0EhVEoGM/D6mH29Lam2JYm22g3bfZk+jHa3QVdpiGOF62C1MCy1ZNA8dDmaoW7K1wc5KQZCNVIYmh2F1hYv94RBp5pSycVxBDOTGcpFl81mQjYL65sx9WaK44A2hulxjzTV5LMpnQ5oZYiilJwvGCp6+A5IIlbXIy5c7vAPL1VpdyyLaSf20MALUsodKdDfaFuzIWMMly5dug47/NWf34snDe1WRBSlRGFMs21IU40xDpdqI1zcHEII2yGWdRUlPyGbFQTaJ+umlsngxRSyihCfjJOSdRISY8fOSGl5t5h08OBsfVFKCRlP4zmWA+q5W2hHt7CHPdOVUhIEAbVabUdto/1FfWOWe/nyZQ4fPnxdwPoPn5jBdxRGKXRqRUxWNizlK9Q+s41hamEOV2o8x+pv5H37Ak2Mg++keI4d3ySk7Ok0aFLjIKUzgBGM7gXpLSvA0NNikFaU3g4chWL29kHpYQ66dwsv1IMM1ai6v18AACAASURBVLZLFPUULvq4KT1AwcA3gyew2/r+X10rpCFdRssWgvClJopVbwCABCRxareXU+M+jiOpDDkMD7ls1hKkMKysx3iuQcUJYxUX34U4Umil2NxMyGVdHMelUtSkSUy1lvA3X6ty5mx9R9e7tfi9W3WYe5bp9qlE230Y+wH2xmxoY2ODfD5/Hb+3XPT44e8r4UrbU5/GKRiIwl5nk4HNboaX5sdYatqhl6qH3eV9RT3JEyrXTqvAUM5GhMIyFiLt9SrbAAIpbTdTqkyvCMNA/Drr2gcuTuxx72QPe9AVQjA/P8/Ro0ffsV87nQ6dTudtL+XJ8Sw/+r4ySZyg0wSVJGxsKqSANNWkqWClXeLs2hityMVzUlyZknUTCrmULhkwBk8mZJyYgh8TY4upagtLQUr7vdIkvVZpF7alu+AbfNcuzPwdGCnw9uaIh8nuNtNthh4STbUJrbbFSlUa0w+sxsBCNIoSdt6dNpayN2gFloL1hrF+UIpy3hCGKUZryiWX1PbEMLsQEgR26nIcG/ZMeAhgZEjSaEbEIahUk8SKSslBGMNYRdJsxqjUoLWL0RJhItIk5ZuvtfidP7jay3rvbFtfqLtFC7wnQbdfKBoaGrrzh3vWp670B/z1H4YrV65w+PDht33+Ix+cZCivqddDmo0YgG4nIUktviSFQGnJ2dUK31kbox37RMolUg5SCiIy1KI8gfIIEw+BIBYejaQwINL3vhn0BAb7wcMYgdbQDCTVlkOzAwU/GXz3W9nDDi/EcUyapjvavfT9eLMs98iRIzcNVj/+gUnGK4JuOyEMEpY3+kG7z/2Ebuzw1voY56vjtOMMYWL96AiI8GgkeWLlkWgX31GE5AZt933OqJQShDN4Zvo7mTgVRLEkiCDrJiRJctvs6GFuernboNuK3MH9Wt2ETifCd11cxzAon2lB1Z/uQQ8Mug17Z2aqYkWscp4iDhUjZYkUEISKoYqH6wj27cngOZJaLcFzDUsrUU/lz0KHE2M+cZjiu4aVNSvnGseacsGhkLG6yPmsQ7MlUGnCRrXD/GLIZ78wz6tv1O6Y9fZ9u5t+3fWg2y+gHTp0aEd/tzUj6l/g6uoq5XLZCmLfxH7xZ6bJuArXsbKLtUaC1qanr2BpQa4DtTDHG6vjbHSyKCV7zQ0Cx3UIVIbYOCRakmqHrs7aRdk7h9K9qbRSDLIjpRRKQye0n8r5MD7k2IkXcXxLR/av62FkLxhjqNfrtx3LfTPbGnT7199qtYjj+LY9///hE3twpR1EmipBu61w3V4HIteggI1unrObk6x18z0fSrRxEI4kMBlCZduGO6k/YCfY6+lP7xY4jn1WtNYYDKm2dMBuJCnn5WB3ciu/PqyslP6L527gheWVGKWF3QFqzflLbTzPgR5lzBhLk113J1CqT70UBLkKUWGM6tHvZWjYZ6wiKeUU+YwmCBIKWUk2a48TJ4I0NbguTE/6GAPjYx5xrGnUA4RwaLUShkoSow0Twx5xlBIEKUmiaLZSclmBThWTYz6+72O0ZKPa4tvnOvzRn23wxa9cpdWOb3md94IOuOs83cXFRXzfv20jxK1MKXUdYXt2dva2wfvYkSKPH87S7cREYUy7leI6lgeklCZJTY+aZ1BacrlaYbZWtp1OPeqQ60KKR6IFGodYu70FaXpTYunxOftbULsIjU4oeV2GCoasb5ioCHzfx3Ec0jS9ada7leP6MGW6QgjW19dxXXfHvfpbyff9oHvx4sU7joXZO53le08UaLViOu2YpbUYrQxK2ckig+CpDcpIltpDXK4PE6XO4KUpJWghCbVLZFz6CmV93VUp+x1p116qWiuCMEYpQy5jGK8IPM/DdV2UUjfNevsdaQ8jbHS3AeXigiGJIuIU2t2YRGUIw3QgwyrQjJQFy2KGtj/KXPEpLuROUs0fpDZ1nLg4RmG4SCYjcVAUsoZCVgCW76sUDI/4RCkIKVhaDXEdgUoN2QwU8xqlJMWcYGU1RCtFkmiyrmC45GC0ppQXVKsRcaxJY/vynhrPMlQqMj1uWFzp8I3TLf6vF+f4h29u3vTlcy/w+l0NummaMjc3R6FQuCtHbr3o5eVlxsbG7hi8f+XnZijmNCpJqdZitLYL0+KxondcBiyEzSDL68ujtCIfv9c+mnEVvi9pJ31KEQPNBdsgIQY/t9tQgZAu3UhTq7WsXq9jMR/ft2/U22W9Dxu8oLXm4sWLjI6O3l2lu/cyBajX6wghtgU9ffyjk4yWwZWKtfV0wG0XPa0EKaxguezxbVuBx5ubYyy17WBFVyg8aac8S2Ef9T4VcOt8tIHWtRYY46KUIOo2cUzMaNEGVM/z8Dzvplnvw9r0AncXdJUytEPB1eUEpGR0vMCefSVakUsQCzK+YXwY9k4K/EKJ+cITJDKDMbDuHYAkQSQRaIXfXEMMjyN1iu9opIBySYLj0OpoikUPx5VMT2YJQ5vFhmFMGEnKJRe0ZmLURWIIggStFdVqRNYTaKUYLrkUcoI40TieZO5q187jyxepVDIUciGbtYg/+5sq//fn51hcDq671gceXlhcXGRmZgbHcXa0ZTHGMDY2xsWLF6lWq2itmZ+f3xYPNJdz+IkfGiYMYovHxVaf1XXosQ+uzVOy3ExDqiUXq6NcqI2CMZbN4KYoIXvsBKu10J/oa2AwTLSP90ohyOfyuF6OoLXK1atXBw+v4ziDrPdm2dHDtg2t1+uMj4/jed6OFqgxhnK5zMrKCktLS4Phh3fqYuublJJf/F8n6LRC5hcj0sQW1AR24ceJsRCB6Rc+LRuhHhW52JykGuXwnJREu73vw6AYunUK8FZWipBQyLmUS3nCboO52YsD3zmOc9Os92GFF2Bn7IWNpuBvzwj+4B89nnyywp79o3iuoFj0KBZ9FA6uY+fJdWPbG58qwYYatYIzGBIl6HSBVJF6BbwkINvZICdTPMdO6Wg0FaWCQyHn4LkOtYYdqeVnXMbHfIzWDJd91jYi0tiyXCSGkbID2lApS9qthG5HoZWm21WUixKDYGosSyHvsLgSkfF92kEeIQ1B0GW9mvKFP1zm//mjJTpdW2jbCi/sVuDd1aC7f/9+9u/fv2MRDa01lUqF5557jvn5eV555RUmJia2/QD/8L8aY2ZMEgYpm5sh2lgeZhxrUmUGAK3uFdj6GXA9yvPK8jSLzSKxcujE13ecGGMGW1rAUozEtc40OynC4dihSTqdDq+++irdbhe4lvX2r2Er3PCwbUNHRkY4evToXYmj5HI5Tpw4QaPR4PTp0ziOs60R3307frTEc8etRka1bpkGW0Zg2QKNsXCD64ie8LmdobYaDHGhNkkjyqJ67BMp+tS+ayxe2WOkSGln6klpMMJh/8wIruvy8ssv02g0AAZZr+/7CGEl//p49cPmV9hZpvvqrMNG26HdMbTaMdoIgsiwtpEQRppUCeot3eNPSxpdq38diRzdyDpLI9gIipCmOEkAQhDlR9BTBxkRdTzHtvgGgSFSgljB9GQWhJVWrTdjPM/FEVAZ9ikVJHFkxY2qtQhH2DWbzwoqJZcksep/zWZKraFxHEOzrThyII/vSoYrGUaHS6zWPJrtgI1qyBvnQz73xSX++h8270lxdNcxXSnljhy5tXiWyWR46qmnCIKAtbU16vX6ts/9yz83jStTui1LgO5DCo5j4QFMb1E6FgdMlUYrQ6wEF6vDnFsboRHaoHutiGapZlsLMLZpAqIYVqqGVmgYG4Jjx45x5MgRXn/9debn59+W9favNUkS4jh+qOCFvu1EHKVfcATwPI/HH3+cNE3pdDqsrq7u6Ly/8nMzeCiWluxYbiksL9pxesBPb3eitSFONGlqenPtJKHyaMfeIMO1363XbdjrSOuLGhkDyhg6XUOrrSnnDAcPHuTJJ5/kwoULnD9/fnBN/eDrOA5JkpCm6UPp1+2+SBMFm3VDlAg8VxBGFl+NQkUY2uakKNY0WoYwtNN5W4GLEJAKj8VmsVfAloTKR3faiB6FbGPoMTZnnkMYCBON6xr8jKBc9FBakioIQsjkHDzPUC76NDoKNDQaCcWClfIcKrkIDO1WAsbQaCXkMpYRkSu4jIxmaLSs2H2rnTK7FFEouMTK8OjhInumhogTCLtdzl8JuTQfkqbpgw0v9G0nQfdG8ZOFhQUOHjzI008/zcWLF7lw4cK2Fvr+mRynnspx+UqLOFZYWUZxLcAaM8B7leopew767KEa5oi1NxC46WN+fa3VwYLt/U4IKOYgnzFM9gZhVCoVTp06RRRFvPLKK3Q6HcA+2Jubm0xMTCCEoNls3pFe9iDaTvG/rX5dX1+nUqnw3ve+l9XVVc6cOUOSbI8rmclIfv7fjXPxUpsgVLZ4pg1J0he0t/5QWyCgvr9UD5zvwwl91sMg65Vi4N8+TBHG9jMjJXuthUKBEydOkM1mefnll6nVaoD1a6fToVAo4HkeQRCQpum278+DYNt9kS5tWnEnrVIMhmzOo9FKyWYkmayk0bIqYSpNaLb7RWxDrWkwQtLVWbqBAeGghEPUCFDZIgDV4ccJvSGCoT1MDEHSmwq9WU8pF12kKxge8mi2UhzHJYg0I0Mujiso5CWpUjSadhCBUoaRYRedagpZQRQqas0EISXNtqJcdBkbtjjxwX05mm3F8lqC0oaltYTpyRLFUoFiPuXkEylBEOA4DnF8a4bDTu2edaRtx5E3UomSJGFlZYW9e/eSz+c5ceIEnudx+vRpWq3WHY/37/+XKXKuxmhbuDGYgW5CXz65vwilBIxGCtt55vVoZ/3ytqE//dfaoIiDbVt0HTsddihnyGzZUTqOw9GjRzl69ChnzpxhdnYWpRRXr15l//79eJ7HSy+9tKMs/kGx7WZF/Sy3nyFs5Vt7nsd73vMexsbGOH369GBkzJ3s+eeGODjj2SxGWKioHzj7bAUrOC7A6N6oln7LaS/Yqh6bhWuFOCmuYf59vL6Ys/+mtkyVEkKwf/9+nn76aS5fvsybb76JUoq5uTkOHjyI53m8+uqr23pOHyTbrk9Xapqcb1CJISdihOlt802K48iBFGfOd+h0IjpdjQAadgwhkckwt+ZhhMQIh8XuEImbxzgeiV/GkYLV3BFMnJDPSVxXUil7pMrQCey6zXiaQsGzLBOlqdYSMh64AkYrDkE3RUpo1BMcR+AIg+fBWMUjTm37vk4Vb5xrIaUgSQ3ZjODRQ3nSFEpFjyQ1XFpIee7pCcqFhKWlJa5evTpIoHblnu/akbbYdjOiG6lEc3NzA0y4//ODBw9y/Phxzp07x5UrV257XNd1+ORPTbK00Orht+B5FlaQwoAwPfUwG+ztyHSzpXrdy5aMzYDlluxnoLfKtZ81O7ee/Ds0NMSpU6dQSvHSSy+RzWbxfZ80TfnGN77Bf/kv/2VnN/UBsO1mRf3dS99WVlYYHh6+jm42NTXFs88+y/z8/CCA3cn+91+c4cL5BlFkP2sLnRbDS5XpdQ7qgb+ufcYG6T6833/oDRZeSNIeZ7c/31AbMq6mcBN2XC6X47nnnqNYLPLSSy/R6XQYGhpCCMEf/uEf8oUvfOGO1/Eg2XZ9euaSIklShLB4bta0GCoYqk2rZ5LNSNJI4/uSQtaj2VIIHVhdhjRFGaiHGesHmaUmx2mbIsrLAoZ26LHhzRCLPK4jqDd1bz4ejA57hLHGcR0aDU2x4OBImBh1qVWtBkunk1LISxxh8dx+UBYYumGKdB3KQxbme/RIgTTVzC4ECAyzV0Nb9C06CCE4/kiO7z05RLFYZHR0lE9+8pO8733v27VdzD3R091O0L0xy42iiI2NDaanp9/22WKxyMmTJ1FK8corrwyKVTezZ54skRORVYnqBUelDGlPBak3WXJAK3N6RbU+zid6318IM6COGdMvtlzDe7WBVheGire+RiklR44cwXVdut0uly5d4itf+Qof+MAHdlRMerdtp37dSrPRWg+ywRstm83yzDPPUCwWefnll++Y/eeyLs8/lcMouyABtOpnrgLR96sQlmHSm2nXZ6JYWl+vkCauvWgHHYi9jNkYQenm/TiD+7B3716GhoZwHIezZ8/y8ssvUygUOHbs2G2v4UGz7SZIVzcMS8sxUajodgOSxCXjaDKeIemGpNqwtAk6SZFS4JPiu5DGLRaXAnypUdowv6RJjSTyy6x08qhMCWNgoy4oFRxqzhhCGCbGrGCR7FHHPFeT8T1Ghl3qDYvZBoFidMSx012EIQxSuh3L1XfQjI96oA3CGIwQzC12QWuSVOM6kuNHC3bIbcFBG8Pr51qAoZB3eORAloWFBaampigUCjz//PMPJnthcNBtwAs3k/g7ePDgLfubpZQ88sgjHD16lNdff52FhYVbPiw//+8m6HZiHCkG7bv9rrL+ud+2CPui5b3/1poBLtVnK/SLLUbbLelI2TA9cvsHttVq4Xkezz//PLOzs/zmb/4m73//+2/7Nw+qbWcreiNGv7S0xPj4+C21SPsB7D3veQ8XL17k4sWLt312/s0PjNKodnpQjy2Uuo4NssYojNHWh72MNUl71DJtizvaGJQxJMm1tuK+3y1MYTBGU87f/jqTJKHVanHq1Ck8z+NjH/sY3/M93/PQtQFvx6frdStGslYzbKw1SI1PGAvCboTvGNodxXA2RhvD5YWITmjXm4oN5WKeKAxRYYOMa7i4oJDCkBiX+VqGtj+CVhDFdnuyrsdQCqLUEMSQzzlkfGziEtr1ODzk4khL/+x0UpTSZDw7sbmQEzQaca8z1k6ZyOcdEIKZySxpqpm/GiCE5tJsF9+BUsGyXp58NM9mLeb4I3k2Nzcpl8v8/u//Pi+88AKf+tSnHnzBm9s58sYsNwgCms0mk5OTdzx2f9ve6XR47bXXCMPw7Z8puTx3BFJtiBIL4gl6rIXUvumsjm6f72m3pFu1AG078RY+p7mWDae6T0ljUES7lc3NzXHgwAE71TiT4ZlnnuHcuXN3vM4H0e60Fb3Rr0opFhYWtsW37mP4ruveEcP/2X8zAsrSAbW2/9LUEKcG6Ti2OMo1Tq7r9LFlCyFobf3q9LjcW38ep1ZKcrR8y9MDlpO+Z88epJSDbWi3293VdtH7YduBF65cTSjIgIxnuLIErtG0u4bNDdsJ5kpNoxpQzBqabY1IQlqBYWklRClDsZCjXtfotIvvarqtgCCCbgQb7nQP4jOsVRWu77MR5HAdQbkgaXUtdOS4LiPDHmFkUFphjKFUkHgOSAy1RoQrQSWK4bJrfW4MroS1zZQUK3buO3D8aIFOVzM27LK8FnH+UhfPFTRbiqkxj3/53qGBSP9XvvIVPvGJT+zqPX9Xgu7NxE8OHTq07SzBcRwee+wxDhw4wGuvvcby8vLbznfyeA7PxGR9aYcbYrMcy0jo4bU9yMG2gNLjfF7jgF5HoOf6RSwFFLKQz9z6O0dRRLfbZXh4GGMMn/3sZ/mP//E/8mu/9mvbus4HzXbq14WFBaanp7dNo7oRw5+dnb3p+TK+YLKc4nkWPtC9CQWOsNMH+nxq1xF4Dghpt5gI+yJ1HQadbGChor6+rhCQz8LM2K39qrVmeXl5IM7/W7/1W3z605/mP/2n//TPMtOdW07ptCPKbotCVrOw0KXR1mzWFWG7a6l6YULRjSjnYX6hQycw1JqaoBWQKkMSG4ZyDo4J+dYbdYSAVsfwrfUR4thmrfVqhBTQinNkM5I4sS32uZxESIc0hdGKi4NtNd6oxuQ868exikcc24GYKlV0O5YuZoxmbNRHYJXHQHN5LqBSsoMLxoYcDu/LcO5CC7RibNgFEyCE4Ktf/Sof+MAHKBZvgyHezT3f1aP17HaL82YSf0EQ3JXu7ujoKCdPnmRzc5M33njjbbSOH3nes8pjsa2keo7Akao3hdR2HznuNUUx1YMT2LIYlTI93ic9NsO19qXh4u0zhIWFBfbu3YsQgkuXLlGv1zl16tSOr/NBsK1MhJvZjX5N05Tl5WX27du343P1Mfw0TW+J4f/LZ/PoKLIUMgvP9/QPNFGiBwVRO/3DZsFbW39VDz6KEzMoujrCBuRy3jBcunXwXF1dZWxsDMdx6HQ6fPWrX+Wnf/qnd3ydD4LdKegaY6zuhTasrWxSKQpAM+x3qDa1pfF1U1RqqG92yfn2Ble8Ls224cKlJt1uSppqaptdSoUMrtQQrhGncH49bzWxY0OzmZBECdpIDA4GiBJNELv4vkM269BNHEIyGAQTIx7r6wES3RNUlxSyEikFhbxDGKZEoSY1Ai0E02MuUaiYHHf5zlstms0EKa0Y+5PHCgSR4unjRebm5ti3bx+f//zn+fSnP73793zXj8jtMd2bjeG5lcTfdszzPJ588kmmpqZ45ZVXWF9fH/xuZMjlx7/Xs6LYvYWmjSBO7GIzPYZYf3uqzTUhFbAUI6W34H29f9rYBXuz6nbflFKsr68PpiK8+OKLfPrTn37oMqGtthO/zs3NsXfv3rvGwW7E8Le2WfftJ78/T8lXg+kPxgiU6hfVzEBnAezuZnDrBzsa05sKIgZFU20g497aR8YYFhYWBi+TL33pS3z0ox+9K4GnB8G2s3tZuVqnXg8w2sEzMcUcLC93KGYNG3VF0mnTDRTtVohMA3K+YXWlRcbVrFUVKuwQhJr6ZgepY4o5l9WlGEekhDHU1hp0QytkXqsGCGMoFT0yrkJKwVDRod4GL+ezd1Lw6GTCgeGIqWybQ5PCBjFjqZzdQBFHVsPB9ySlkks3MghHsrnRpZi3296jh4uMDHssrkRIR1KtpRzen+fk03na7Tbnzp3j8OHDd5U03Mnua6Z7YzbUbDZJ05Th4TsAo9uwiYkJTpw4weLiImfPnh3QOyZHHX7mX/scqoTE7QY6tenOtRE8vYq3sdtTozUqTTGpQhqNLzUOFvBTqQ3OqqdyNT1669u3tLTE1NQUUkpqtRpf//rX+fCHP/yOr/PdtO36NY5j1tbWtjUb707Wx/Db7Tbf+ta3rsPwHUfw49+XpaIv4iVtMiKm6KcMZRKGMwn7KiknDsMPPOPz/mc8vve4z3sOOhyekOwfc5goe+R9CUYQxnYentYwdBtiSa1WI5/Pk81mUUrxxS9+kV/8xV98x9f5btntMF1jDLV6wuvnOqRRhzh16LYjXGnIZQRDfpesL/jWmSZJnNLuKDrNLo7QeNIwXgjwXXj9jTrtTkK7q2g32jhCY1TKWC7ElZp/enmddjuhEyg2V1qoVLG2FjI5naWUFzS7sHcmR8bv0U4A34GZfIdHc8uMiRo5zwCajC8o5iVJbAu6QagoljJI12G47FKvx6ysx7iuoNVRHDpQoFh08TMOP/qD4ywtXmXv3r187nOf4zOf+cw9uef3pGfxZotza1vo1iz3ThJ/OzHf93n66adZXl7m9OnTHDt2jOHhYYSAY3tbDLlrHH3s+EBlCnotncK2CtquRJshOVvammwdTQ+KaQZIUwtT3MyMMSwuLnLixAkAfu/3fo+Pf/zjD12L6I12q6B7Y5Y7Ozs7KB7uhvUx/M3NTV577TUOHTo02EF0u13Kfo33n7zTbsn+LpuRZG+TlEZxukVo++02Nzc3eGb/8i//kpMnTzI+Pr7ja3pQ7Hbwwv98ucOf/2OXA0dGyWSgFTooT1JtphidwfVSKkWIQ0nc7bBWg6CrmZ6y9ZBmPWByJMN8x+DpgOWaJu4GjI4XcaWhutZiqFigWYVgc5F2UqJjIqTnsLES8vToFFMTPpcWIrsz9cD0qIKm14YopGTcb+GkXS60CqCzxJHCcSSeJ0g9Ozlvs6bZW7Ti5gcms1xdjfB9h1hpZmcT/sWJIY4dzvHNb64zOjpKo9G4Z1DgrkaBrWMt7qRNWavVkFJSLt+hTHwX32HPnj0MDw9z9uxZSqUShw8f5sqVKzzxxBNkdumKfffWC7Pf8up5HkmS8OUvf5l//Md/3J0Tv4t2swV6s2GT1WqVo0eP7vr5+xj+W2+9xdraGo899thAc3m3YJvMrbpdsPUHrTWlUgljDJ/73Of4r//1v+7Ked8tu9WLdGUj5f/7WoTnSoaHNF1V4pEpq10yOppBCsPVdU1xWFMeyeOgyJQUrolxHUG3m4DRZIkZG3aYX+hQGc6yvBZTKYcoJTFKUSkmtEouGxsROqNR3ZDRYUm91iFodpm9EuBksiwsaOp5wcFxQckVXPvGvZijU8ZFnWUxjlEaz5O0Wym5nA+uw9SIS1hNoQib9YQ9k1lcT9ANYGYyy/d/9zDLy8tMTk7yuc997p5CgfcFXrhZW+hOJP7uxvqdQ9lslpdeegnXdcnn8/fsfFttfn6e/fv3A/A//sf/4Ad/8Ad3/eXybtjNtqI341vfOGxyN20rht/XQRgdHb0n57rR+vQ/gDNnzpDJZHj88cfvy7nvld0KXnj1bIfJEYMrI4xx2TuqubpqdY2DUJMkhoNTEm0khZykFUimJzJ42TxaZPDzBYZHi/jZDGPDPkePFJkedTj+aAGlNFlfUyi46NQG5f37ihzb77B3Jkc7iGiGOa7MRrRjH8cV5FzDWl3wjfNF/nZumvWohMLqOIAdy2OMplBfwUsDYlzyeQfXc6h3bPEmnxFkPTsxZnkt5NJsgBSGqQmfxx7Jc/XqVYrFIt/4xjf40Ic+dM/u+X0Lulv/f3Nzk2w2u+tUjJt9j77eQRRFXL58eUc6v3djjUYDz/PI5/Norfnt3/7te1IBfTfsZn7dmuV2u11ardZ92W5PTExQqVRwXZdz587dc6GZOI5pNpuDAP/Zz36Wz3zmMw91YRRuvXt59Ttdqptd0iigkPfodGIOTtp6Rqcds7Kp2KwmjJYNQWQYHRKcOR+Ry4J0oJgXnLscY4wg0ZKM77CwqtFGstkEjQtCEiYSz7VatwvLCUHkoJSL43osr0dUioooMrS7iqFszPiQINAF/r71NF+PnyMkC0L2pq/19Djabfy1JeqZMcLU1H59MAAAIABJREFUYXQ4gyPsNIt6O2VsNEul5HFgJsPaRsyhfVk2NjYYGhriD/7gD+45FHjP2At9R25dmP1F2x9KeD+sXq+TzWZ573vfC3Cd+te9sK3Z0D/90z+xd+/em7bAPox24wLdybDJ3bYoimi325w6dYpKpcLp06cH6l/3wrbS/1ZWVnjzzTf5gR/4gXt2vvtlt9q9XF6IWVqNaDQMcZSQJIZ2M2S8YjnPlVzC/HLKxmaEiyKOUw7scXjjfIBSmk435fhhn4XlGGEM80sxB2Z8tDZUyi6btZSzlwI8B1odhVGa/VMO+awhDBMOzjiEkcPrbwVE3Ta1pmKjmpJ0AvJZ8D1Y9g/yZ+WfYtnbh+l1E4oe9Q+jGV04Q662RNgOCLuKnG8o5e3EF8d1iBPbbvyvvqsyaIb48pe/vOvNEDfaPct0+468sS10bW3ttsMmd9uuXLnCoUOHkFJy+PBhjh07xpkzZ67TvN0tC4KAKIqoVCoA97QCer9tq5YCvD3LbbfbRFF022GTu2lbO/327NkzUP/aqnm7W6aUYm1tbaAL8vnPf55PfvKTu1YofDftxhdpkmiWVkJGi7Z4tbqhWJir02on1JspUTcgn7U6ukdnDHNLMZ12RBgoTJrwyF6PuashQaBYW484sMel01WMDUteO9fpqcIZhoqCowc8Ls0HoFNWN2IWV0J03KRSzhB0Eo7MwFjFYe5qTNrZYHUzZW4pottoD0ZpJV6Brx16gfOV57H5ck8hEECAn3aZWf0WBzvnCOodhBB4nkt5yGezppiZ9HFliJSSv/iLv7gvUOCuPzVbM9obp/v2Jf4O7XBS8N1as9lECHGduEy5XObkyZOEYcirr75KEAS3OcLObCuWe+XKFdbX1/nu7/7uXTv+u21b/XojE+XixYv3LcuN45hqtXpd2/hWDP/06dM0m81dO9/KygoTExM4jkO32+VP//RP+Zmf+ZldO/67aTcG3f/zd2t89Rs2eTg0bRgfcQkCRdzpsLaZMHc1RMcRjjS02xHH9jvML4VIUtY3E6SJ2TPuEgQxQai4eKVDMS9IE8MTR3wuXOnQbMa0OylhoDh60Edpq0sdxwmX5gWusO36rVbCRNmwZyJDqyvJiw02aoozb3aI2u0B195Ih3NP/AznZn4QSX+HDVuqbRS66zyTuUg2bbNeNwQRHDlc5IM/MDFohvjt3/5tfvVXf/Xe3/N7cdD+4rwxy11eXmZ0dPS+Ecn77cU3muM4PProoxw+fJhvf/vbLC0tveOsN0kSqtXqAM988cUX+ZVf+ZWHHvPbalsx3a1+bTQaGGMGGf69tv7L7cZ728fwn3zySd58881dwfBvbIb48pe/zEc+8pEdT0V+UG3r7mVhOUKahJfOJOSHigyPlTk4k2F8xCFJNDOjmloj4dtnG6Bi4kgRByGHZlwWl0OKOc2FKwGuSBgqSApZTc4XvPFmE4Gm3U557EgWR0K3mxJGisuzIUMFQdYHT0Qc3udw9nyHJIyp1mI2NiMKfspYxQeTYWqoQaoUL71SI+l26IZWm8EAC09+iPOPfHDQxNRv3e/TPKUjMXHMkX0Z4kTw3JMl9u+xL9Lz58+zd+/ebemEvFO7px1pW7ef/WGT9wvfbLVaaK1vO3V2eHiYkydPUq/Xef3119+ROvzS0hIzMzNIKWk0Gvz93/89H/nIR+76eA+i9f26lYkCu8+3vp0lSXJdp9/NrFAocPLkSeCdY/h9tan+hOff/d3f5VOf+tRdH+9Bs60v0rMXQ4LQMFZokZosS5uC0HjM7Bti/948EputZjzBq9+uoVXK+maMSROmxhwajYipMYdXz7QRJrVqbQU4vDfDhSu2KWLuaki5IBkfcZAYZqY8vnW2RaudkKYKYyRPPZajGyh8R7NRjbk828aTimxGYpTLvvGUnJ/y6qtrxEFIo9VXkoPFJz/Ipcd/yF4b13be/alOriO4shizbybDD/7LyuCFej+hwHuO6fYX5uLi4o6GTb5T2y6M4boux48fZ8+ePbzyyiusra3t+Fxaa5aWltizZw8AX/ziF/nYxz720DdD3Gh9v27dFVSrVVzXvW/6wP1Fcic8dbcw/K1Tqf/qr/6Kp59+eltqeA+L9eGFKFZcWYxJ05QkFYwUBONDDkEI7RBCnaFYyeN6LscO53nP4yU2NkKE0Fy43MFBkc8KVJLyxCNZq02rNRubIVJoHj2YpdlKGB92eetih5W1mGLBIYo0Tx0rYExMO7AzzmYXIibHPLIZwUgZlNZ8+0wNYVIwoBLD/mmfYi7l8ltXicKYjZomiGzWO//UB5h9/FqR00Cv0UmAMIwMuTz/dAGBZn19nU6nc1+hwHsWdPvZEHDduJr7YZ1OhziOd9RePD4+zokTJ1hZWdnR/C6wxcHR0VFc1yVJEr70pS/xwgsv3M1Xf+DtRibKveZbb7U0TVldXR283LZjN2L4N5MCvZW1Wi2EEBQKBYwx/Lf/9t/+2RRG+9b34/JaxNiQod3uEKcZ1qoJaZJQytuiVM6HC3MKx/MQrg+uy+RUkfGRDI8dLdLs6dq6riCJFc89UaLRiMnlJHMLAcsrIWPDLsYYDh/IMj7qceFyF601G9WEONE8erhgx6SPe8xe7RInBt+TTIx47J/JcOZsE9fRtDsJKk6ZnshRzEmaK1eRIqXaUHS6hlTB4skfYfH4+wawbl9FLooN+6Z83vuewqBVvy9sc7+gwHsSdHO5HM1mcyA0vrCwwJ49e+5b5ne3xTrf93nqqacYHR3d9vwuY8x1BbQ/+ZM/4fu///vvG755P81xHKSUg2GhGxsbFAoFCoXCfTn/1atXBxDOTqyP4R86dIjXXntt2xj+Vvrf2bNnEULw5JNP3tV3f1CtDxntmXBRSQcdJ5RzmtWNhLcuh1SrEWmiiRPDY4c95pYSlIYwEgxXfGptSLUk1ZKR4RzaCFxfsrAcMjycpVRw2TudZbji8tobTVSi6AYpcWw4/mgBz5ekKmakkuX85S5xInAcwcxUnnLBZXElwhiDJwXPPlkiSWwrhHQktXrK8HCB6ckisrvMeDm0olVYZsPav/gQy49+H2YwIdFCDo8czCKE3X2XSiW+9rWv8RM/8RP3757v9gGNMbiuy4kTJwiCgNdee43FxUX27t2726e6qQVBQBAEd01dEkIwPT3Ns88+y9zc3B3nd9XrdXK5HNlsFmMML7744n2pgN5v6wepZ555hkwmw+nTp7lw4cJ9Y6Iopa7TsL0bGxkZ4dSpU9vC8MMwHGghwzX63z+nwmjf+lDgvrFlPv6TU0ijOTJtGC5LNqoJK6sdGu2EtY2Uw3vtkMd83uH8ldA2HriSylCG1Y2EIBJ4rsvERB4/Izl/OcTzHVIFJ54eIog17ZbG9+HcxQ7VWko+m2KEx6F9BYYrLourCUZIam3NsaMlUiWQjuDynOUAj1Ts8SpDPrmsQ60l0E4ZFQaU3E32TyoKOYkjYf35D7Nw6PvRvc41Vyqeecw2Q1QqFb70pS/dFRT4iU98gomJibt6Ce960O070HVdjh07huu6KKXuKXF9q/XH/rzTxZHNZnn22WcH87sajcZNP7c1G/rmN7/J1NQUhw8ffkfnfhCtj+VKKTlw4ADj4+MkScLm5uZ9mZawuLjI9PT0Ox6Zsl0Mv48dCyFYW1vjzJkz/NAP/dA7OveDaK7rEkURFy5coFKp8Nx7RvjMv5+hXHIYyqfsm/Yo5B2iboxSirMXLU9XYNg37VOtpyyvpwhgqOwxMeZxaT5ESqjVE556vEi7kyKk4Mp8l2LeYWZPBqUEB2Zy5LMJa9UMjaZCG8PapuLg/jy+J8lmXDqBJjUO2ZzHnukctXrCt840CcOUJNHUm4qRisvEiItwc/iZHJdm6zSrDUYKCt8TbJz4Md488AEikcF3JWMj3qAZ4m6hwI9//ON89atfvat7vqtBd2lpiV//9V8f4GZxHNPtdjl16hQLCwu89dZb97QNNwxD2u32XQmi38y2zu86f/782+Z3dTodlFIDMnW/NXSn9k7emvfDoiji137t1wZwi9aa1dVVTp06RbPZ5PXXX98RBr5T01rv+m5pK4b/ne9857rvr5RiY2NjUDD7nd/5HX7hF35hx7DGg+5XgN/4jd+gVCoxPz9PkiQopRgquXzqZ/cwPeFj0oShomCoKHFJ2T/lWKnHRNMJUkYqkpkJl6W1BDAsryU8/kiBODEUCi4X5wKyWYd81mF0NEOzpXjjbBMhDEmS0g0Ujx7KMT3h0w0N5ZJko5Ywt5RSLrt4nsPEuM/8corru0xP+jz1eIlaPWZ2oYPnKGYXApZXY4aLtvFhYrRAIZvw6hsN1lcaOCg2jv1r/uqJ/40jP/Q8zWYTx3H467/+a97//vffluF0K/u+7/u+u95N72rQnZqaYv/+/Xzwgx/k7NmznD9/ngMHDpDL5XjmmWfI5XKcPn2adru9m6cdWF9ScLe3gPl8npMnTw7md/W//1Ysd35+nuXlZb7ne75nx8d/J2/N+2GZTIb3v//9/Nt/+2/5u7/7O2ZnZxkbGyOfz3P8+HGmp6c5ffo01Wr1npx/aWmJycnJXa8J9DH8kZGR677/Vi3kIAj44z/+Y372Z392x8d/0P0K8JGPfIRPfOIT/P7v/z6VSoWXX36ZVqtFLuvwyZ+e5olH89SqthlCSiw74WiWzXpCHCpW1mMaLcXh/T5hpBkddjnzVhtHCDxXsmcqi9ZwcS4k4zuUSw7vebxErRZzdTkgn3e5cjVkaTVmuOzgSDsV+MgBj9mrEe2uodPVHNyfRwpJJ5K0u5rDB/Ic2Jul2UoZqwiiSPHad1rEUQIGHDfHkX2SOOpy7q0aYaeLyZV47keeG6zb/mCB+227GnSllHzmM5/h85//PC+88AIvvPACExMTwDXi+uOPP853vvOdm04CeCcWRRGNRmNwvt22/vyuxx9/nLNnzw7G7/Sz6hdffJFf/uVfvquA/07emvfLfvInf5I//dM/5T//5//Mj/3Yj123m5iYmODZZ5/lypUrd5zmu1PTWl/XnLDbthXDn52d5c033+Tq1auDrPq///f/zoc+9KG7alt/GPz63ve+F8/zEELwm7/5mxw6dIhz584xNzeHlIKf+tAUP/2hSa7MdXGlYbOWUK9F7J1wyGUFOd+QKs133uxSzttxSUcP5QgixfxSZFlaQnD8aJ6rS3YHvLIeMTbiMD6SIoXP6JDLSMXhjTc7rKzHSAGNpuLATIahskOrbYgTxXpdMTmRRToOQaRJE8PIsIsjBeWC4egBn0uzAUtLnZ6oumCkkmO8krC60uC7nhQDrP78+fPvGhR4T9gLzz77LM899xyTk5N87GMfuy4DKpVKnDx5klar9Y4bErba3NzcTbuUdtv6379Wq6G1Hkwy/pu/+Rs++tGP3tNzv9u2f/9+PvzhD3PkyBE++tGPcuXKlcHvstkszz33HI7j3HKu2d3YysoK4+Pj95zf3cfwtdaDgaJaa77whS/wS7/0S/f03O+mOY7D1772Nb7yla/wwz/8w/z4j/84YKG6b33rW0RRxHedGOL/+PUjOBLKRcnV5YA3L7TJegbfFeR9waOHM5y71CVONI1WSrHgcvT/b+/Mo6Oqsr793FtTqiokZIAMZA6EhCCiCfq9n4qtbTcRlcFmCtoiwRERZ+TFT21F2sbuVpcLBwTBoVvQ1lcFFBxoQkS7gSQgEEIkkJB5nmuuuuf7I516KUSBJFQG6lkra8G6lXvOrZ3adc4+e/92nB8NjQ5UGjhebiUxzgCyjL+/hpITZhqa1Bj8OpvCKoogNUlPUIBMWaUVtVpwotJKh8nFiHA1LqWzJ1rBUTMGgwaVWkXAUB0VVbbOBqWA06kwdpQfWq1EWbkJtaxQUW3H6VQTGqzCaS6kqKjI68UQp3LeFDueeOIJvvzySzIzM5k8eTLffvut+5pKpSIlJYWIiAjy8vJ6vC09XS3++cbhcJCSksLevXtZtmwZt9xyi9cKP/qSzMxMPv30U1auXMncuXPZuHGje8ciSRLx8fEkJSVx4MCBHpdXn5qOd76RJAmz2cxFF11EUVERTzzxhPvvdDDj7++PJEncfvvtfPjhhzzxxBNs3ryZESNGkJ+fT0NDA1ERfixdFEdCrB9xUZ0pYPsL2jCZ7FisTjo6nKSM1CMhcDgEZouT42U2YiJ1ICQihvtRWWOjrV3BTysRGOgiOlJPQVEHdXUWFJdCXYMdtQoSonU4HYKh/p0r54NHLBh0Eg5FYWSsHpPFSVWtA5dTEDXCiEYj09yuoFHLNDXbiQrTEBmuo7HJyvBgmWOlFgIMWtIuvZjGxkbeeecdampquhUK7A3Om9NNTExElmVmzZrF5s2b+eMf/8gzzzzjcWBx8ra0K/ezO5SVlZ1VlVJv0bX6Cg4OZty4cezcuZPvv//eK6f4fU1ERARGo5Err7yS7OxsvvrqK+666y4PgZnAwED3buBcC01Opra2luDgYLRabW9N/xfp0kIOCQnh0ksvZffu3Rw4cOC8SoH2N5KSktixYwcdHR1kZWUxYsQIysrKKCoqwk8nce/vo7lsfCBGvcz4Mf44nILWNjsgKDpmRqeVO9ukyzLRI7QcKjJhsSggwbBQP4aHavmx1IJBr8fuUBiX4k9ggJraWiv+ejheZqGk3IJR3ynf6KeB5ITO+1gtCiaTE3+9mvgoPyprHShCUNvgJDbagKSS0em1mKydfiQuxoDLqTB2tJ7EWD0NDQ3u8EllZSWlpaXdfp8yMzP5r//6L4qKioiKiuKtt94669/1ipeKjY1l+/bt6PV6brjhBo+H7dqWajQacnNzz/kPvKsW31urkVMFUHbu3Mn111/Pa6+9NihzOH+JoKAg3n//fX7961+TkZFBbm6u+5parSY1NZVhw4aRl5dHS0vLOd1bCOGRjucNTh7vxx9/xN/fny1btnit+KO/oNVqWblyJUuXLmXmzJlUVVW51dtMJhMzbwzjdzcMp7LGTniolvBhWlwuhbgoLaXlZo6XWdD7SVgsguSRRgx6mer/ZDfUNNiJCldQa3SoVGqqau3o9WqiI3XY7QqRoSqMeom8H9qwWZ04nQKLVeGi0XqsVictrXbaTU4amh2MjPPD4RAYjSrqG+3UNLgIDNCi89MQEOiHwyVjtquIizZy/TUhVFVVERAQwJEjR8jJyenRDmrDhg1UV1fjcDioqKhgwYIFZ/270hlWZ72+dMvJyeH+++/n4YcfZsaMGR6Oqq2tjcOHDxMdHU1kZORZObHjx4+j0WjO20HLqTQ2NlJTU0NqaipCCDIyMli3bl2PeoJlZmaSnZ3tTlN65plnTmfE3vTovW7XoqIibr/9dm644QYeeOABj3xai8VCQUEBQUFBbm3jM1FXV0dTUxPJycm9PdXTYrFYOHTokLsZ4f3338/06dO58cYbu33PPrAr9LJt6+rq3CveZcuWcezYMaKiohgxYgSVNTaef+U4LgWCAtQ4XAKdtrPNdnmVnWGhWjrMLgx6FaFBGlraHTjsdto6FAx6HcOC1HRYXGhUgqPHTIweZcRidiGrJPR+Ko6X20AIhoXqcDghNEiFzQ5NLQ4CA1SUVzsYGeuHIjpDGga9iuMVNtRqFXEjdJisCsGBWu6ZOwybpYmmpia2b9+OEIIlS5b05tt0On7Wrl53utDZlPLuu+/Gz8+PP//5zx5iKU6nk6KiIlwuFykpKb8YJ3U6nezdu5fLLrusx0nzZ0t+fj5JSUn4+/uTm5vLiy++yCeffOKNVW6/drrQmUGybNkyfvjhB1avXu2x+1AUhdLSUpqamkhNTf3FbAAhBHv37mXcuHFek1AsKipi6NChhIWFUV9fz/Tp08nNzfVGyKpfO13otN2qVat49913efXVV1GpVDgcDsaMGYPdIfPGu+Xs2t3IyHgjzW1Kp5MN1mCyCmw2Bb1eprjURmKsHlNHK/5DAvDTqSgsNhEf7YfD3nnw1txiQ1E6lcAAAgPUNLc6aWl1MixUS3mljfgYP2SVhNUqMOglDv1oJmSohojhOpyKhFYroVGrqGl0giQz+epAbrims7NIUlISkyZNIjs7+5x0WbrJz9q1T6Tvg4KC2LhxIxMnTiQjI4P8/Hz3ta5taVhYGHl5eb9YyVZRUUFkZKTXHG5Xfm5Xb7fB0iert9DpdPzlL3/h0UcfZdq0aXzxxRfuOHeX6tfIkSP54YcfqKmp+dn7NDY24u/v7zWH63A4aG5udqcbrlu3jjvvvHNQdIboDWRZZvHixaxdu5aFCxfy3XffERYWRm5uLnZbGw/eFcusKRFYrJ2HZGqV4IfDHTjsCkajCoREapKBDpOV+mYtarVMc5uTMaOMqNQSHRYZm72zb9rwYXqcLtDqZE5UWAgwqogI02KzOkmI8ePA4TZqa61oNWCzK4wdpUerljhU1AFCobHJQWu7k4hQNVFhav7vpf7uWP0///lPJk6c6A2H+4v0yUr3ZAoLC5k/fz5Tp05l0aJFHg7UarVSUFBAYGAgCQkJHh8Cl8vFnj17vLrKLSgoIDw8nJCQECoqKpg3bx7fffedtz6c/X6lezK1tbVkZWURExPDc88957GydTgcHDlyBEmSSE5O9ih6EEKQm5tLamqq17o3l5aWIssyMTExWK1Wrr76anbv3u2t8fv9SvdkzGYzDz30ENXV1bz44otUVVUxdOhQEhIS2LWnhW07GnE4BXq9ioZmJ/VNDkbFGWjrUBCKifCwoTS1uJBlCadLweGUiArX0mF2IktQ32gjwF+D3g/sdgWXS6Gh0U5MpB8WqxONRkVFlZXmNgdjRvljsSoY9TKyRqa2vvPAdmighppGwYSLh7B4XjgHDx4kKiqKzMxM1q1b5y3t5/610j2ZlJQUdu7cSV1dHTfffLPHCqjrkE2WZfLy8jxa61RWVhIeHu41h9vVCLEr2f2NN97gvvvu862GfoawsDA2b97M6NGjycjI4PDhw+5rGo3GQ83tZF2L5uZm9Hq91xyuoihUV1e75SL/8Y9/cNNNN3lt/IGGwWDgjTfeYN68edx88810dHS4P58TLtazdFE88TF6GpsdBPqrGJtkwGRWcLnsSLKG4hM2Aoao8DfKGPRqwoZpOFxsxubobI0+fJiegAA1xyscqDVqZJWKuFh/zDZBu6VTojE8zI+0iwKpq7eh00nUNdoxtTuJCtcyNECNzaYwIkzF+BQ9VqsVq9VKcXExISEhXpMh/SX6fKXrHkgItm7dyuOPP84zzzzDpEmTPLbtLS0tHDlyhNjYWMLCwti9ezcTJkzwmlxkcXExBoOByMhI2tvbue6668jLy/NaOhMDbKV7Mvv27eOOO+5g3rx5ZGVleXxRmc1mCgoKCA0NJS4ujvz8fJKTk72WMVBTU0N7ezujRo1CURSuueYaPvvss3PS7O0hA2qlezLl5eXcdtttpKens2jRIo4dO0ZsbCwREREcKOxg9XsVtJsV4qL1NDW3YjAMwaBXc6LShsMpSIo3YP5PzFdRBCUVduIidbSbXAQFqlEUhbpGJyGBKppbHUSEaelod6IICZvNgVarwl8v09zqQJYVqmvsxEfrEXLnYd5/L4yhuuo4AQEBLF26lPvuu4+rr77aW29P/13pdiFJEpMnT+brr79mzZo1LFmyxENweujQoaSnp9PY2MjevXsJDQ31msN1uVweLWL+9re/kZmZ6U2HO6C55JJLyMnJ4cCBA9x6660eOsUGg4G0tDR3uEiWZa853K7ii67Ml5ycHJKTk73pcAc00dHRfP311wQEBDB37lxCQ0NpaGjg0KFDjBnlx4t/SCLjV8EUHu2gqVWFn07GbFWIjtAxMk5PaZUNh0OhudWF2SIYk6jH6eyMIZvMLmobFKIj/JBkicBAHS1tCi0micAADf5DdBiNGqrrXfjpNRj0WhLijJyosnCizERUWGeIorGxEbvdTnl5OVdddVVfv2VAP3K6XYSHh/P555+TkJBARkYGhYWF7mtdsnx2u52GhoZzzv3sLtXV1W4BFJfLxbvvvsvdd9/tlbEHC0ajkTVr1jB37lxuuOEGcnJy3NdkWXbH2cxmM7W1tV6Z06layN1VibuQUavVPPnkk7zwwgvcdttt7tTA3NxcrJZ2MqeGccsNFkYnGDl+woKiuGhsdtDa5iQxWodOK+NyCXQaOHzUhkolMTRAhVqtIiJMw7FyKy3tYNCrMBg0REfqqGl00doBsqwiLEzPkAAtVQ0KKrWKmCgD0VF+RIbp3C203nzzzX4VCuw34YXTkZeXx5133klWVha33347sixTVVWFyWQiKiqKQ4cOERISQnx8/HnLIBBCsHv3btLS0tBoNGzevJns7Gxef/318zLeLzBgwwunUlZWxm233cbll1/OsmXL0Gg0tLa2UlJSQmpqKoWFhW495vMZs9+/fz8JCQkEBARQVFTEI488wvbt272djTJgwwun0tLSwr333ossy6xYsYITJ07g5+eHWq0mMXE0/7OtgbyD7VhsLgx6NRU1DuKidGg0Mg4naNQS9Y1O2kwKyQl6rHYFjUZCJUsUl9kYEaZFCIFWq0Kvk6issePvr0JxCYwGGaEoNLc5iQlTsfD3keTn7yE5OZmMjAxvhwJhIIQXTkdaWho5OTnk5+dz2223UVdX544b6fV60tLSEEL85JCtN+lSmNdoNO7OEA8++OB5GetCISYmhm+++cajQvHIkSPEx8e7D9kCAwPZu3evR3lxb3KqFvJrr73GAw884Ev/6wFdnRiuu+46pk2bhqIoVFRU0NHRgaLYmTNlOLdMG05osBaEYFSMlrJKK0ePmdGqO1PAQoNVjI7XcqysU+zGYnFhtgpSEjvDDK0dnQLq5TUOwob7EeCvRqEzhlvdIIiK8OP3N4fT0tJAcHAwGzduZO7cuf0qFNivV7pdCCH44IMPeOGFFxg9evRP6pybm5spKioiPj7Kh6MTAAAQcklEQVS+10Vv8vLySElJwWAwkJ+fz8qVK9m0aVNffDgHzUr3ZL799lsWLVqEwWDgm2++8XhfTSYTBQUFDB8+vNd1kgsLCwkNDWXYsGE0NjYyZcoUcnNzvZYNcxKDZqV7MkVFRcydOxej0ch7771HcXExiYmJDB8+nOZWJ2s3VFHf5ECnlXE4BScqbERH+mG2CYwGFUOHqGjtUGhpUxgeqqaq3knkcC1GvUy7ubM5qs0uaO0QJEZrsTlcKIrExHQj11ze2e0lJSWF3/zmN+zYsaMvJDYH5kq3C0mSmDVrFi6Xi5KSEp577jkPEZWgoCDS0tKora2loKAAp9PZK+N2Kcx3pQ+tWrWKhx9+2Lca6kWuuuoqEhMT0ev13HPPPbS3t7uvGY1G0tPTcTgc7Nu3D5vN1itj2u12Wltb3ZrA69atY8GCBX3hcActo0ePJjAwkKSkJBYsWEBUVBRVVVUUFhYS4C/xyF3RjB/jT32TA0kIUkb6YbG6cDqdWG0Kx8tt6HUQMUyNzSaIDFFT22DnyHErBj8JtQoMfjLxURqOnrDR1CIIGari6glGWlpa0Ol07NixgyuuuKLfaRoPCKcLnY73/fffZ9euXajVam666SZOnDjhvt61Le0K4vfGtvRkAZTKykpKSkq8mXJywfDss8/yzTff8Ktf/eonFYqyLDNq1ChiY2PJz8+nvr6+x+N1iZRLkoTNZuOjjz5i/vz5Pb6vD08++eQT1qxZw2OPPeYWzukqnzebTcydFsb8meFU1FipqrExLLhzhas4nQwPljl4xExdgw1/gwQShA5VERep5tCPFhqaHKhUYLUJEqK1BAfKjEn0Q5Ylj84Q/TEUOKCcbmpqKmq1mmeffZbly5cze/ZsPvroIw8918jISLceamlpabflFq1WKxaLxd1KffXq1SxcuLDfnIAOJsaOHYssyyxYsID333+fRx99lJdfftmjC3NISAhpaWlUVlaesUPzL9HV361LF+Ljjz9m8uTJF5ySmDcIDAxEkiQmTZrE119/zfr163nppZdITEykoKCA8vJyLhs/hOeXJiLJ8ENBOypJYNTLOOwuUhK0tJuc7D/UjoSCw+nC4RKMHalDJcORY2YkodDY4kStlrjyUgMWiwWbzUZJSQkBAQE9EqI6XwxYD3L11VeTnZ3Npk2bWLhwoUffNaPRSFpamntbenK+79nS9W0pSRIdHR1s27aNOXPm9OYj+DgNXRWK9fX1P6lQ1Gq1XHzxxRiNRnJzcz1CEWdLTU0Nw4cPR6VSoSgKa9as4f777+/NR/BxGroqFJOTk7n55pvx9/fHZDLxww8/MDxE5oVlI0kfN4T9h9poabHhcilYbS6iwtQkxOooKjZhMTkxmZy0tLsIDpRJSdDR2OLAYXcyMlqDViu7P7f9WRdlwDpdgODgYD788EOuuOIKMjIy2Ldvn/ta17Y0Li6Offv2/Wyr7dPhdDppbGx0C6D8/e9/Z/bs2eh0ul5/Bh8/RafT8eKLL/LQQw8xdepUtm3b5rGbiY6OJjU1lcOHD1NWVnbWu5kuLeSu/me7du0iMTGxV7sM+/h5ZFnmwQcfZM2aNdxzzz3s2rWLyMhI8vLysNtaeezeOOZOD6e13UFpmQnFpdDR4UQtuUhO1OFwKjQ0WkFRKK+y0dHhJGKYiiFGFeNG63E4HDQ1NeF0Ojl+/Hi/DQUOiOyFs+Hw4cPMnz+f6dOnc99993kcitjtdgoLC9FqtSQlJZ3xwKTrgxwbG4vL5eKqq67im2++6bXW7t1kUGYvnImamhqysrKIj49n+fLlHspjLpeL4uJizGYzqampZ0wLOlULec6cOTz11FNuDd0+YlBmL5wJk8nEgw8+SF1dHS+99BJVVVUMGTKExMREyqtsfLq1jn/vayUqwo+aehshQzUED9XQZha0trsIDVZzrNxJ4BA1Y0bqeTArgrKyMiRJ4q233mLs2LHMmzevLx9xYGcvnA1jxoxh586dVFdXM2PGjJ9sS8eNG8eQIUPOuC1VFIXKykpGjBgBwLZt27j88sv72uFesISHh7NlyxYSEhKYNGmSR4WiSqVi9OjRREdHk5eXR0NDwy/e6+SD0eLiYtrb20lPTz+v8/dxeoxGI2+++Sa33nor06ZNo7293d09JjRI4YE7Y/nvRXEMC9USFaGnvcPJ8RNm/PUSwYEqrBYXceEqXIpC4BAVQgiqqqoIDAxk69at/ToUOGicLnSqkr388svcf//9TJ06la+++spjWxoVFeWuePq5bWl9fT0hISGo1eoeF0Ns27aN0aNHM3LkSP70pz/16NkuZGRZ5pFHHmH16tXcddddrFu3zqOfXmhoKJdeeinl5eUUFRWdttfeqVrIr7/+OosXL+5WzG8g2fVMc7XZbMyePZuRI0dy+eWX96hv2LkiSRIzZ85ky5YtrFy5knfeeYfExEQOHjxIVVUVF6UMYcm9cUydNIykUQHERBs5WmICoaBWS4Ag2F8wYZyRuro6QkJC+OCDD5gzZ063QoFes6sQ4pd+TsvWrVtFUlKSSExMFM8///xPrlutVjFr1iyRmJgoLrvsMlFSUvJztzpvVFVVid/+9rdi0aJForGxUZhMJvdPe3u7yM/PF7t27RJNTU0e17Kzs0VDQ4MwmUzi+++/F5MnTxaKopzz+E6nUyQkJIhjx44Jm80mxo0bJwoKCnrySGey1bn8nJaBYNeOjg6RlZUlpk+fLsrLyz1s19HRIQoLC8WOHTtEbW2tx7U9e/aIsrIyYTKZREVFhRg3bpxwOp3nPH4/t6uHbc9mrq+++qq4++67hRBCbNiwQcyaNasnz9JtHA6H+MMf/iCuuOIKcfDgQbFnzx7x73//W7S0tPznM9shPt9eKZ76a5F4bPkhMXfhXrFw6X6x+P/tF80tbSI7O1vU1dWJ8ePHi/r6+nMe35t2PeeVrsvl4r777mPr1q0cPnyYDRs2eGilArz11lsEBQVRXFzMQw89xOOPP95rXxJnS0REBF988QUxMTFkZGRw5MgR9zVZlt3b0q4W04A7qbpLcLsnJ6B79uxh5MiRJCQkoNVqmTNnDp999lnvPNx5YKDY1Wg0snbtWmbPns3kyZPZtWuX+5okScTExJCSkkJBQQEVFRUIIX6ihbx+/XqysrK6VQwxkOx6NnP97LPP3LHPGTNmuHuIeRu1Ws3TTz/N888/zy233MKhQ4cIDQ11NzWVZYlf/Z+hPHrnCK68PJhRo4aiN2pIvzgAs6kdPz8/du7c2e1QoDftes5OdyAZUqVS8dhjj/Haa6+xYMEC3n777Z9sS9PS0tzb0tLSUnfMr7q6mh9//JFrr722W2NXVlZ6NMuMioqisrKyZw90HhlIdpUkidmzZ7Np0yZWrFjB8uXLPSoUhwwZQnp6Ou3t7Rw4cIDS0lKio6ORJAm73c4HH3zQ7WKIgWTXs5nrya9Rq9UEBgZ6SG96m6uuuors7Gy2bdvG008/TWJiIkePHuXYsWMIIVCpJK67IpAH54fz+9+F87vJYZw4cYKYmBi3fkZ38KZdz9npDkRDpqen8+2337Jnzx7mzZvn0XdNq9Uyfvx41Go1TU1N7tXP6tWr3YpJ3eF0zqg/5gx2MRDtGhcXx/bt29Fqtdx4440eFYoqlYqUlBTCwsKoqKhwZzZ88sknTJo0yS10c64MJLuezVz74/MEBQWxYcMGrrnmGqZNm+b+DJ4sbKXVyIyK9cNsNuNwOCgtLUWv13e7e7Q334dz9igD1ZD+/v6sX7+eGTNmMHnyZL777jv3NUmScDgc7kqZHTt28Pnnn3PLLbd0e7yoqCjKy8vd/+9qotlfGah2VavVPPPMM6xYsYI5c+Z4VChCZz+2mJgYTpw4QXZ2Nm+++SaLFy/u9ngDya5nM9eTX+N0Omltbe0XWgVdFYobNmxgyZIlbN68mfj4ePbv3++ht1xeXk5MTAyvvvpqj4ohvGnXc3a6A9mQkiSRmZnJp59+yvLly1mxYgVOpxOHw0FLSwsxMTGkp6fz+uuvI4ToVsVTFxMmTODo0aOUlJRgt9vZuHEjU6ZM6cWn6V0Gsl0BJk6cyI4dO9i8ebO7QlEIQWVlJXFxcVx66aV89dVXlJaWYrfbuz3OQLLr2cx1ypQpvPPOOwB89NFHXHvttX3+RXoyycnJZGdn09DQwPz584mJiaG2tpbDhw9jtVppbm7G5XL1KBQIXrbrL52yne5IzuFwiPj4eHH8+HH3Kd+hQ4c8XrNq1SqPE9GZM2f25BTwvGC328UTTzwhJk6cKF566SXxr3/9S5hMJtHW1ibGjx8v3nvvPVFRUdGjMT7//HMxatQokZCQIJ577rmeTvm8Zi8MFru6XC6xevVqcckll4jXXntNfPrpp+7MhqlTp4r169eLvXv39miMfmzXn9j2dHN98sknxWeffSaEEMJisYgZM2aIxMREMWHCBHHs2LGePs95QVEU8cUXX4ixY8eKjz76SBQVFYmtW7eKffv2iSVLloi33nqrx2N4y67dSi0aLIYUQogvv/xSBAUFibVr14qOjg7x8ccfi6ysrL6e1uk47yljg8muBQUFIiwsTCxdulS0tbWJgwcPiiuvvLJb6X/nmfPqdAcb1dXV4vrrrxf33HOPWLp0qXjooYdEamqqMJvNfT21U/lZGw2aMuDukpOTw5YtWyguLiYwMJCSkhJWrVrF2LFj+3pqp3JBlgF3l6qqKh555BHCwsIoLCwkMjKSyZMnM3PmzL6e2qlckGXAPUFRFObNm0deXh5Tp04lJyeHzMxMFi1a1NdTO5mftesF73Thf1f7f/3rX3nzzTf58ccf+1Vc6z/4nO450vW3vWXLFu644w4qKirQaDR9PKuf4HO63WDx4sVcf/31zJs3j71797oVAfsRPqd7tggh+pvxuvA53R5wgdgVLjDbDkS7+pzuwMHndAcnPqc7OBn8KmM+fPjwMRDwOV0fPnz48CI+p+vDhw8fXsTndH348HHOnEl79u2332bYsGGMHz+e8ePHs3bt2j6YZf+k3zhdnxEHJz67Dj7ORgYUYPbs2ezfv5/9+/dzxx139MFM+yfqvp4A/K8Rv/76a6KiopgwYQJTpkxhzJgxHq+bPXs2q1at6qNZ+jhXfHYdnJwsAwq4ZUBPtauP09MvVroDSRjax9njs+vg5Gy1Zz/++GPGjRvHjBkzPMSULnT6hdP1GXFw4rPr4OR0uf2nFijcdNNNlJaWcuDAAa677rq+7szbr+gXTtdnxMGJz66Dk7ORAQ0JCXE3h7zzzjvJy8vz6hz7M/3C6fqMODjx2XVwcjbas9XV1e5/b9q0iZSUFG9Ps9/SL5yuz4iDE59dBydqtZpVq1YxadIkUlJSmDVrFqmpqTz11FNs2rQJgFdeeYXU1FQuvvhiXnnlFd5+++2+nXQ/4kzaC15DkqTJwMuAClgnhFghSdKzQK4QYpMkSc8DUwAn0ATcK4Q48vN39NEf8NnVhw9P+o3T9eHDh48LgX4RXvDhw4ePCwWf0+0mkiTNlCSpQJIkRZKk9L6ej4/ewWdXH+cbn9PtPoeAm4Gcvp6Ij17FZ1cf5xWf0+0mQohCIURRX8/DR+/is+vgo7/tXnxO14cPH4OdfrV7+f+MrhCccNMDngAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用Tester_Burgers进行预测，复现文章中的Figure1（只画出预测结果）\n",
    "args = Options_Burgers().parse()\n",
    "args.problem = Problem_Burgers()\n",
    "\n",
    "args.model = PINN(2, 1, dim_hidden=args.dim_hidden, hidden_layers=args.hidden_layers)\n",
    "args.testset = Testset_Burgers(args.problem)  \n",
    "tester = Tester_Burgers(args)\n",
    "tester.predict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x648 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tester.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3、非线性薛定谔方程"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "考虑带周期边界条件的非线性薛定谔方程：\n",
    "$$\n",
    "\\left\\{\n",
    "\\begin{array}{rl}\n",
    "i h_t + 0.5 h_{xx} + |h|^2 h = 0, & x \\in[-5, 5], ~~ t \\in [0, \\pi/2]\\\\\n",
    "h(0, x) = 2\\mathrm{sech}(x), & \\\\\n",
    "h(t,-5) = h(t, 5), & \\\\\n",
    "h_x(t, -5) = h_x(t, 5), & \n",
    "\\end{array}\n",
    "\\right.\n",
    "$$\n",
    "其中$h(t,x)$为复值函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1、问题描述"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Problem_Schrodinger(object):\n",
    "    \"\"\"Description of Schrodinger equation.\"\"\"\n",
    "    def __init__(self, domain=(0, np.pi/2, -5, 5)):\n",
    "        self.domain = domain\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return f'{self.__doc__}' \n",
    "    \n",
    "    def f(self, x, verbose=None):\n",
    "        num_data, _ = x.shape\n",
    "        out_u = np.zeros((num_data, 1))\n",
    "        out_v = np.zeros((num_data, 1))\n",
    "        if verbose == 'tensor':\n",
    "            return torch.from_numpy(out_u).float(), torch.from_numpy(out_v).float()\n",
    "        return out_u, out_v\n",
    "    \n",
    "    def g_init(self, x_init, verbose=None):\n",
    "        num_data, _ = x_init.shape\n",
    "        out_u = 2.0 / np.cosh(x_init[:, [1]])\n",
    "        out_v = np.zeros((num_data, 1))\n",
    "        if verbose == 'tensor':\n",
    "            return torch.from_numpy(out_u).float(), torch.from_numpy(out_v).float()\n",
    "        return out_u, out_v\n",
    "    \n",
    "    def g_bc_1(self, x_bc_1, verbose=None):\n",
    "        num_data, _ = x_bc_1.shape\n",
    "        out_u = np.zeros((num_data, 1))\n",
    "        out_v = np.zeros((num_data, 1))\n",
    "        if verbose == 'tensor':\n",
    "            return torch.from_numpy(out_u).float(), torch.from_numpy(out_v).float()\n",
    "        return out_u, out_v\n",
    "    \n",
    "    def g_bc_2(self, x_bc_2, verbose=None):\n",
    "        num_data, _ = x_bc_2.shape\n",
    "        out_u = np.zeros((num_data, 1))\n",
    "        out_v = np.zeros((num_data, 1))\n",
    "        if verbose == 'tensor':\n",
    "            return torch.from_numpy(out_u).float(), torch.from_numpy(out_v).float()\n",
    "        return out_u, out_v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2、数据集生成"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Trainset_Schrodinger(object):\n",
    "    def __init__(self, problem, *args, **kwargs):\n",
    "        self.problem = problem\n",
    "        self.domain = problem.domain\n",
    "        self.args = args\n",
    "        self.method = kwargs['method']\n",
    "\n",
    "    def __call__(self, plot=False, verbose=None):\n",
    "        if self.method == 'uniform':\n",
    "            n_x, n_y = self.args[0], self.args[1]\n",
    "            x, x_bc_1, x_bc_2, x_init = self._uniform_sample(n_x, n_y)\n",
    "        elif self.method == 'lhs':\n",
    "            n, n_bc = self.args[0], self.args[1]\n",
    "            x, x_bc_1, x_bc_2, x_init = self._lhs_sample(n, n_bc)\n",
    "        f = self.problem.f(x)\n",
    "        g_init = self.problem.g_init(x_init)\n",
    "        g_bc_1 = self.problem.g_bc_1(x_bc_1)\n",
    "        g_bc_2 = self.problem.g_bc_2(x_bc_2)\n",
    "\n",
    "        if plot:\n",
    "            fig = plt.figure()\n",
    "            ax = fig.add_subplot(111)\n",
    "            ax.scatter(x[:, 0], x[:, 1], facecolor='r', s=10)\n",
    "            ax.scatter(x_bc_1[:, 0], x_bc_1[:, 1], facecolor='b', s=10)\n",
    "            ax.scatter(x_bc_2[:, 0], x_bc_2[:, 1], facecolor='b', s=10)\n",
    "            ax.scatter(x_init[:, 0], x_init[:, 1], facecolor='b', s=10)\n",
    "            ax.set_xlim(-0.01, 0.01+np.pi/2)\n",
    "            ax.set_ylim(-5.2, 5.2)\n",
    "            plt.show()\n",
    "\n",
    "        if verbose == 'tensor':\n",
    "            f = torch.from_numpy(f).float()\n",
    "            g_init = torch.from_numpy(g_init).float()\n",
    "            g_bc_1 = torch.from_numpy(g_bc_1).float()\n",
    "            g_bc_2 = torch.from_numpy(g_bc_2).float()\n",
    "            x = torch.from_numpy(x).float()\n",
    "            x_bc_1 = torch.from_numpy(x_bc_1).float()\n",
    "            x_bc_2 = torch.from_numpy(x_bc_2).float()\n",
    "            x_init = torch.from_numpy(x_init).float()\n",
    "            return x, x_bc_1, x_bc_2, x_init, f, g_init, g_bc_1, g_bc_2\n",
    "        # (N, 2)\n",
    "        return x, x_bc_1, x_bc_2, x_init, f, g_init, g_bc_1, g_bc_2\n",
    "\n",
    "    def _uniform_sample(self, n_x, n_y):\n",
    "        t_min, t_max, x_min, x_max = self.domain\n",
    "        t = np.linspace(t_min, t_max, n_x)\n",
    "        x = np.linspace(x_min, x_max, n_y)\n",
    "        t, x = np.meshgrid(t, x)  \n",
    "        xy = np.hstack((t.reshape(t.size, -1), x.reshape(x.size, -1)))\n",
    "\n",
    "        mask0 = (x_max - xy[:, 1]) == 0\n",
    "        mask1 = (xy[:, 1] - x_min) == 0\n",
    "        mask2 = (xy[:, 0] - t_min) == 0\n",
    "        mask3 = mask0 + mask1 + mask2\n",
    "        x_bc_1 = xy[mask0]\n",
    "        x_bc_2 = xy[mask1]\n",
    "        x_init = xy[mask2]\n",
    "        x = xy[np.logical_not(mask3)]\n",
    "\n",
    "        return x, x_bc_1, x_bc_2, x_init\n",
    "\n",
    "    def _lhs_sample(self, n, n_bc):\n",
    "        t_min, t_max, x_min, x_max = self.domain\n",
    "\n",
    "        lb = np.array([t_min, x_min])\n",
    "        ub = np.array([t_max, x_max])\n",
    "        x = lb + (ub - lb) * lhs(2, n)\n",
    "        \n",
    "        sample = lhs(2, n_bc//2)\n",
    "        lb = np.array([t_min, x_min])\n",
    "        ub = np.array([t_max, x_min])\n",
    "        x_bc_1 = lb + (ub - lb) * sample\n",
    "\n",
    "        lb = np.array([t_min, x_max])\n",
    "        ub = np.array([t_max, x_max])\n",
    "        x_bc_2 = lb + (ub - lb) * sample\n",
    "\n",
    "        lb = np.array([t_min, x_min])\n",
    "        ub = np.array([t_min, x_max])\n",
    "        x_init = lb + (ub - lb) * lhs(2, n_bc//2)\n",
    "        return x, x_bc_1, x_bc_2, x_init"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2000, 2) (50, 2) (50, 2) (50, 2)\n"
     ]
    }
   ],
   "source": [
    "problem = Problem_Schrodinger()\n",
    "# trainset = Trainset_Schrodinger(problem, 40, 40, method='uniform')\n",
    "trainset = Trainset_Schrodinger(problem, 2000, 100, method='lhs')\n",
    "\n",
    "x, x_bc_1, x_bc_2, x_init, f, g_init, g_bc_1, g_bc_2 = trainset(plot=True)\n",
    "print(x.shape, x_bc_1.shape, x_bc_2.shape, x_init.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Testset_Schrodinger(object):\n",
    "    def __init__(self, problem, *args, **kwargs):\n",
    "        self.problem = problem\n",
    "        self.domain = problem.domain\n",
    "        self.args = args\n",
    "        self.method = kwargs['method']\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f'{self.__doc__}'\n",
    "        \n",
    "    def __call__(self, plot=False, verbose=None):\n",
    "        if self.method == 'uniform':\n",
    "            n_x, n_y = self.args[0], self.args[1]\n",
    "            X, t, x = self._uniform_sample(n_x, n_y)\n",
    "        elif self.method == 'ground_truth':\n",
    "            data = scipy.io.loadmat('NLS.mat')\n",
    "            t = data['tt'].flatten()[:,None]\n",
    "            x = data['x'].flatten()[:,None]\n",
    "            Exact = data['uu']\n",
    "            Exact_u = np.real(Exact)\n",
    "            Exact_v = np.imag(Exact)\n",
    "            Exact_h = np.sqrt(Exact_u**2 + Exact_v**2)\n",
    "            t, x = np.meshgrid(t, x)\n",
    "            X = np.hstack((t.reshape(t.size, -1), x.reshape(x.size, -1)))\n",
    "            if plot == True:\n",
    "                fig = plt.figure()\n",
    "                ax = fig.add_subplot(121)\n",
    "                ax.scatter(X[:, 0], X[:, 1], facecolor='r', s=0.01)\n",
    "                ax.set_xlim(-0.01, np.pi/2+0.01)\n",
    "                ax.set_ylim(-5.1, 5.1)\n",
    "                ax = fig.add_subplot(122, projection='3d')\n",
    "                ax.plot_surface(t, x, Exact_h, cmap=cm.coolwarm)\n",
    "                plt.show() \n",
    "            \n",
    "        if verbose == 'tensor':\n",
    "            X = torch.from_numpy(X).float()\n",
    "            \n",
    "        if self.method == 'uniform':\n",
    "            return X, t, x\n",
    "        elif self.method == 'ground_truth':\n",
    "            return X, t, x, Exact_h\n",
    "\n",
    "    def _uniform_sample(self, n_x, n_y):\n",
    "        t_min, t_max, x_min, x_max = self.domain\n",
    "        t = np.linspace(t_min, t_max, n_x)\n",
    "        x = np.linspace(x_min, x_max, n_y)\n",
    "        t, x = np.meshgrid(t, x)\n",
    "        X = np.hstack((t.reshape(t.size, -1), x.reshape(x.size, -1)))\n",
    "        return X, t, x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "testset = Testset_Schrodinger(problem, 40, 40, method='ground_truth')\n",
    "X, t, x, h = testset(plot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3、网络结构"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grad(outputs, inputs):\n",
    "    \"\"\" compute the derivative of outputs associated with inputs\n",
    "    \n",
    "    Params\n",
    "    ======\n",
    "    outputs: (N, 1) tensor\n",
    "    inputs: (N, D) tensor\n",
    "    \"\"\"\n",
    "    return torch.autograd.grad(outputs, inputs,\n",
    "                               grad_outputs=torch.ones_like(outputs),\n",
    "                               create_graph=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResPINN_Schrodinger(ResDNN):\n",
    "    \"\"\"Physics Constrained Neural Networks\n",
    "    \"\"\"\n",
    "    def __init__(self, dim_in, dim_out, dim_hidden, res_blocks,\n",
    "                 act_name='tanh', init_name='xavier_normal'):\n",
    "        super().__init__(dim_in, dim_out, dim_hidden, res_blocks, \n",
    "                         act_name=act_name, init_name=init_name)\n",
    "        \n",
    "    def forward(self, problem, x, x_bc_1=None, x_bc_2=None, x_init=None):\n",
    "        x.requires_grad_(True)\n",
    "        uv = super().forward(x)\n",
    "\n",
    "        u = uv[:, [0]]\n",
    "        v = uv[:, [1]]\n",
    "        grad_u = grad(u, x)[0]\n",
    "        grad_v = grad(v, x)[0]   \n",
    "        u_t = grad_u[:, [0]]\n",
    "        v_t = grad_v[:, [0]]\n",
    "        u_x = grad_u[:, [1]]\n",
    "        v_x = grad_v[:, [1]]\n",
    "        u_xx = grad(u_x, x)[0][:, [1]]\n",
    "        v_xx = grad(v_x, x)[0][:, [1]]            \n",
    "        x.detach_()\n",
    "       \n",
    "        f_1 = v_t - 0.5 * u_xx - u * (u ** 2 + v ** 2)\n",
    "        f_2 = u_t + 0.5 * v_xx + v * (u ** 2 + v ** 2)\n",
    "        \n",
    "        if x_init is not None:\n",
    "            g_init = super().forward(x_init)\n",
    "            x_bc_1.requires_grad_(True)\n",
    "            x_bc_2.requires_grad_(True)  \n",
    "            h_1 = super().forward(x_bc_1)\n",
    "            h_2 = super().forward(x_bc_2)\n",
    "  \n",
    "            ux_1 = grad(h_1[:, [0]], x_bc_1)[0][:, [1]]\n",
    "            ux_2 = grad(h_2[:, [0]], x_bc_2)[0][:, [1]]\n",
    "            vx_1 = grad(h_1[:, [1]], x_bc_1)[0][:, [1]]\n",
    "            vx_2 = grad(h_2[:, [1]], x_bc_2)[0][:, [1]]\n",
    "            x_bc_1.detach_()\n",
    "            x_bc_2.detach_()\n",
    "            \n",
    "            g_init_u = g_init[:, [0]]\n",
    "            g_init_v = g_init[:, [1]]\n",
    "            g_bc_1_u = h_1[:, [0]] - h_2[:, [0]]\n",
    "            g_bc_1_v = h_1[:, [1]] - h_2[:, [1]]\n",
    "            g_bc_2_u = ux_1 - ux_2\n",
    "            g_bc_2_v = vx_1 - vx_2\n",
    "            \n",
    "            return uv, f_1, f_2, g_init_u, g_init_v, g_bc_1_u, g_bc_1_v, g_bc_2_u, g_bc_2_v\n",
    "        return uv, f_1, f_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4、Options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Options_Schrodinger(object):\n",
    "    def __init__(self):\n",
    "        parser = argparse.ArgumentParser()\n",
    "        parser.add_argument('--no_cuda', action='store_true', default=False, help='disable CUDA or not')\n",
    "        parser.add_argument('--dim_hidden', type=int, default=20, help='neurons in hidden layers')\n",
    "        parser.add_argument('--hidden_layers', type=int, default=5, help='number of hidden layers')\n",
    "        parser.add_argument('--res_blocks', type=int, default=6, help='number of residual blocks')\n",
    "        parser.add_argument('--lam', type=float, default=1, help='weight in loss function')\n",
    "        parser.add_argument('--lr', type=float, default=1e-3, help='initial learning rate')\n",
    "        parser.add_argument('--epochs_Adam', type=int, default=2000, help='epochs for Adam optimizer')\n",
    "        parser.add_argument('--epochs_LBFGS', type=int, default=100, help='epochs for LBFGS optimizer')\n",
    "        parser.add_argument('--step_size', type=int, default=1000, help='step size in lr_scheduler for Adam optimizer')\n",
    "        parser.add_argument('--gamma', type=float, default=0.7, help='gamma in lr_scheduler for Adam optimizer')\n",
    "        parser.add_argument('--resume', type=bool, default=False, help='resume or not')\n",
    "        parser.add_argument('--sample_method', type=str, default='uniform', help='sample method')\n",
    "        parser.add_argument('--n_x', type=int, default=100, help='sample points in x-direction for uniform sample')\n",
    "        parser.add_argument('--n_y', type=int, default=100, help='sample points in y-direction for uniform sample')\n",
    "        parser.add_argument('--n', type=int, default=5000, help='sample points in domain for lhs sample')\n",
    "        parser.add_argument('--n_bc', type=int, default=100, help='sample points on the boundary for lhs sample')\n",
    "        \n",
    "        self.parser = parser\n",
    "    def parse(self):\n",
    "        arg = self.parser.parse_args(args=[])\n",
    "        arg.cuda = not arg.no_cuda and torch.cuda.is_available()\n",
    "        arg.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
    "        return arg\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5、训练过程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_model(state, is_best=None, save_dir=None):\n",
    "    last_model = os.path.join(save_dir, 'last_model.pth.tar')\n",
    "    torch.save(state, last_model)\n",
    "    if is_best:\n",
    "        best_model = os.path.join(save_dir, 'best_model.pth.tar')\n",
    "        shutil.copyfile(last_model, best_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Trainer_Schrodinger(object):\n",
    "    def __init__(self, args):\n",
    "        self.device  = args.device\n",
    "        self.problem = args.problem\n",
    "        \n",
    "        self.lam = args.lam\n",
    "        self.criterion = nn.MSELoss()\n",
    "        \n",
    "        self.model = args.model\n",
    "        self.model_name = self.model.__class__.__name__\n",
    "        self.model_path = self._model_path()\n",
    "        \n",
    "        self.epochs_Adam = args.epochs_Adam\n",
    "        self.epochs_LBFGS = args.epochs_LBFGS\n",
    "        self.optimizer_Adam = optim.Adam(self.model.parameters(), lr=args.lr)\n",
    "        self.optimizer_LBFGS = optim.LBFGS(self.model.parameters(), \n",
    "                                           max_iter=20, \n",
    "                                           tolerance_grad=1.e-8,\n",
    "                                           tolerance_change=1.e-12)\n",
    "        self.lr_scheduler = StepLR(self.optimizer_Adam, \n",
    "                                   step_size=args.step_size, \n",
    "                                   gamma=args.gamma)\n",
    "\n",
    "        self.model.to(self.device)\n",
    "        self.model.zero_grad()\n",
    "        self.x,     self.x_bc_1,     self.x_bc_2,     self.x_init    , self.f    , self.g_init    , self.g_bc_1    , self.g_bc_2     = args.trainset(verbose='tensor')\n",
    "        self.x_val, self.x_bc_1_val, self.x_bc_2_val, self.x_init_val, self.f_val, self.g_init_val, self.g_bc_1_val, self.g_bc_2_val = args.validset(verbose='tensor')\n",
    "        \n",
    "        if self.device == torch.device(type='cuda'):\n",
    "            for item in [self.x, self.x_bc_1, self.x_bc_2, self.x_init, self.f, self.g_bc_1, self.g_bc_2, self.g_init, \n",
    "                         self.x_val, self.x_bc_1_val, self.x_bc_2_val, self.x_init_val, self.f_val, self.g_bc_1_val, self.g_bc_2_val, self.g_init_val]:\n",
    "                item = item.to(self.device)\n",
    "        \n",
    "    def _model_path(self):\n",
    "        \"\"\"Path to save the model\"\"\"\n",
    "        if not os.path.exists('checkpoints'):\n",
    "            os.mkdir('checkpoints')\n",
    "\n",
    "        path = os.path.join('checkpoints', self.model_name)\n",
    "        if not os.path.exists(path):\n",
    "            os.mkdir(path)\n",
    "        return path\n",
    "    \n",
    "    def train(self):\n",
    "        best_loss = 1.e10\n",
    "        \n",
    "        for epoch in range(self.epochs_Adam):\n",
    "            loss, loss1, loss2 = self.train_Adam()\n",
    "            if (epoch + 1) % 100 == 0:\n",
    "                self.infos_Adam(epoch+1, loss, loss1, loss2)\n",
    "                \n",
    "                valid_loss = self.validate(epoch)\n",
    "                is_best = valid_loss < best_loss\n",
    "                best_loss = valid_loss if is_best else best_loss                \n",
    "                state = {\n",
    "                    'epoch': epoch,\n",
    "                    'state_dict': self.model.state_dict(),\n",
    "                    'best_loss': best_loss\n",
    "                }\n",
    "                save_model(state, is_best, save_dir=self.model_path)\n",
    "                \n",
    "            \n",
    "        for epoch in range(self.epochs_Adam, self.epochs_Adam + self.epochs_LBFGS):\n",
    "            loss, loss1, loss2 = self.train_LBFGS()\n",
    "            if (epoch + 1) % 20 == 0:\n",
    "                self.infos_LBFGS(epoch+1, loss, loss1, loss2)\n",
    "                \n",
    "                valid_loss = self.validate(epoch)\n",
    "                is_best = valid_loss < best_loss\n",
    "                best_loss = valid_loss if is_best else best_loss                \n",
    "                state = {\n",
    "                    'epoch': epoch,\n",
    "                    'state_dict': self.model.state_dict(),\n",
    "                    'best_loss': best_loss\n",
    "                }\n",
    "                save_model(state, is_best, save_dir=self.model_path)\n",
    "            \n",
    "    def train_Adam(self):\n",
    "        self.optimizer_Adam.zero_grad()\n",
    "\n",
    "        _, f_pred, g_bc_1, g_bc_2, g_init = self.model(self.problem, self.x, self.x_bc_1, self.x_bc_2, self.x_init)\n",
    "        loss1 = self.criterion(f_pred, self.f)\n",
    "        loss2 = self.criterion(g_bc_1, self.g_bc_1) + self.criterion(g_bc_2, self.g_bc_2) + self.criterion(g_init, self.g_init)\n",
    "        loss = loss1 + self.lam * loss2\n",
    "\n",
    "        loss.backward()\n",
    "        self.optimizer_Adam.step()\n",
    "        self.lr_scheduler.step()\n",
    "\n",
    "        return loss.item(), loss1.item(), loss2.item()\n",
    "\n",
    "    def infos_Adam(self, epoch, loss, loss1, loss2):\n",
    "        infos = 'Adam  ' + \\\n",
    "            f'Epoch #{epoch:5d}/{self.epochs_Adam+self.epochs_LBFGS} ' + \\\n",
    "            f'Loss: {loss:.4e} = {loss1:.4e} + {self.lam} * {loss2:.4e} ' + \\\n",
    "            f'lr: {self.lr_scheduler.get_lr()[0]:.2e} '\n",
    "        print(infos)\n",
    "        \n",
    "    def train_LBFGS(self):\n",
    "\n",
    "        # only used to compute loss_int and loss_bc1 for monitoring\n",
    "        _, f_pred, g_init, g_bc_1, g_bc_2 = self.model(self.problem, self.x, self.x_bc_1, self.x_bc_2, self.x_init)\n",
    "        loss1 = self.criterion(f_pred, self.f)\n",
    "        loss2 = self.criterion(g_bc_1, self.g_bc_1) + self.criterion(g_bc_2, self.g_bc_2) + self.criterion(g_init, self.g_init)\n",
    "\n",
    "        def closure():\n",
    "            if torch.is_grad_enabled():\n",
    "                self.optimizer_LBFGS.zero_grad()\n",
    "            _, f_pred, g_bc_1, g_bc_2, g_init = self.model(self.problem, self.x, self.x_bc_1, self.x_bc_2, self.x_init)\n",
    "            loss1 = self.criterion(f_pred, self.f)\n",
    "            loss2 = self.criterion(g_bc_1, self.g_bc_1) + self.criterion(g_bc_2, self.g_bc_2) + self.criterion(g_init, self.g_init)\n",
    "            loss = loss1 + self.lam * loss2\n",
    "            if loss.requires_grad:\n",
    "                loss.backward()\n",
    "            return loss\n",
    "\n",
    "        self.optimizer_LBFGS.step(closure)\n",
    "        loss = closure()\n",
    "\n",
    "        return loss.item(), loss1.item(), loss2.item()\n",
    "        \n",
    "    def infos_LBFGS(self, epoch, loss, loss1, loss2):\n",
    "        infos = 'LBFGS ' + \\\n",
    "            f'Epoch #{epoch:5d}/{self.epochs_Adam+self.epochs_LBFGS} ' + \\\n",
    "            f'Loss: {loss:.2e} = {loss1:.2e} + {self.lam:d} * {loss2:.2e} '\n",
    "        print(infos)\n",
    "\n",
    "    def validate(self, epoch):\n",
    "        self.model.eval()\n",
    "        _, f_pred, g_bc_1, g_bc_2, g_init = self.model(self.problem, self.x_val, self.x_bc_1_val, self.x_bc_2_val, self.x_init_val)\n",
    "        loss1 = self.criterion(f_pred, self.f_val)\n",
    "        loss2 = self.criterion(g_bc_1, self.g_bc_1_val) + self.criterion(g_bc_2, self.g_bc_2_val) + self.criterion(g_init, self.g_init_val)\n",
    "        loss = loss1 + self.lam * loss2\n",
    "        \n",
    "        infos = 'Valid ' + \\\n",
    "            f'Epoch #{epoch+1:5d}/{self.epochs_Adam+self.epochs_LBFGS} ' + \\\n",
    "            f'Loss: {loss:.4e} '\n",
    "        print(infos)\n",
    "        self.model.train()\n",
    "        return loss.item()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adam  Epoch #  100/2200 Loss: 2.6155e-01 = 4.1477e-02 + 1 * 2.2008e-01 lr: 1.00e-03 \n",
      "Valid Epoch #  100/2200 Loss: 2.6036e-01 \n",
      "Adam  Epoch #  200/2200 Loss: 1.7444e-01 = 3.4716e-02 + 1 * 1.3972e-01 lr: 1.00e-03 \n",
      "Valid Epoch #  200/2200 Loss: 1.7344e-01 \n",
      "Adam  Epoch #  300/2200 Loss: 8.3542e-02 = 3.5125e-02 + 1 * 4.8418e-02 lr: 1.00e-03 \n",
      "Valid Epoch #  300/2200 Loss: 8.2965e-02 \n",
      "Adam  Epoch #  400/2200 Loss: 4.5417e-02 = 2.5249e-02 + 1 * 2.0168e-02 lr: 1.00e-03 \n",
      "Valid Epoch #  400/2200 Loss: 4.5178e-02 \n",
      "Adam  Epoch #  500/2200 Loss: 2.9596e-02 = 1.8712e-02 + 1 * 1.0885e-02 lr: 1.00e-03 \n",
      "Valid Epoch #  500/2200 Loss: 2.9498e-02 \n",
      "Adam  Epoch #  600/2200 Loss: 2.2830e-02 = 1.4980e-02 + 1 * 7.8502e-03 lr: 1.00e-03 \n",
      "Valid Epoch #  600/2200 Loss: 2.2784e-02 \n",
      "Adam  Epoch #  700/2200 Loss: 1.9310e-02 = 1.2908e-02 + 1 * 6.4024e-03 lr: 1.00e-03 \n",
      "Valid Epoch #  700/2200 Loss: 1.9283e-02 \n",
      "Adam  Epoch #  800/2200 Loss: 1.6949e-02 = 1.1487e-02 + 1 * 5.4624e-03 lr: 1.00e-03 \n",
      "Valid Epoch #  800/2200 Loss: 1.6929e-02 \n",
      "Adam  Epoch #  900/2200 Loss: 1.5059e-02 = 1.0322e-02 + 1 * 4.7365e-03 lr: 1.00e-03 \n",
      "Valid Epoch #  900/2200 Loss: 1.5041e-02 \n",
      "Adam  Epoch # 1000/2200 Loss: 1.3415e-02 = 9.2914e-03 + 1 * 4.1233e-03 lr: 4.90e-04 \n",
      "Valid Epoch # 1000/2200 Loss: 1.3399e-02 \n",
      "Adam  Epoch # 1100/2200 Loss: 1.2358e-02 = 8.6218e-03 + 1 * 3.7361e-03 lr: 7.00e-04 \n",
      "Valid Epoch # 1100/2200 Loss: 1.2348e-02 \n",
      "Adam  Epoch # 1200/2200 Loss: 1.1368e-02 = 7.9903e-03 + 1 * 3.3772e-03 lr: 7.00e-04 \n",
      "Valid Epoch # 1200/2200 Loss: 1.1358e-02 \n",
      "Adam  Epoch # 1300/2200 Loss: 1.0445e-02 = 7.3994e-03 + 1 * 3.0455e-03 lr: 7.00e-04 \n",
      "Valid Epoch # 1300/2200 Loss: 1.0436e-02 \n",
      "Adam  Epoch # 1400/2200 Loss: 9.5937e-03 = 6.8528e-03 + 1 * 2.7409e-03 lr: 7.00e-04 \n",
      "Valid Epoch # 1400/2200 Loss: 9.5855e-03 \n",
      "Adam  Epoch # 1500/2200 Loss: 8.8121e-03 = 6.3485e-03 + 1 * 2.4636e-03 lr: 7.00e-04 \n",
      "Valid Epoch # 1500/2200 Loss: 8.8046e-03 \n",
      "Adam  Epoch # 1600/2200 Loss: 8.0925e-03 = 5.8794e-03 + 1 * 2.2131e-03 lr: 7.00e-04 \n",
      "Valid Epoch # 1600/2200 Loss: 8.0856e-03 \n",
      "Adam  Epoch # 1700/2200 Loss: 7.4246e-03 = 5.4362e-03 + 1 * 1.9884e-03 lr: 7.00e-04 \n",
      "Valid Epoch # 1700/2200 Loss: 7.4182e-03 \n",
      "Adam  Epoch # 1800/2200 Loss: 6.8005e-03 = 5.0135e-03 + 1 * 1.7870e-03 lr: 7.00e-04 \n",
      "Valid Epoch # 1800/2200 Loss: 6.7945e-03 \n",
      "Adam  Epoch # 1900/2200 Loss: 6.2188e-03 = 4.6129e-03 + 1 * 1.6059e-03 lr: 7.00e-04 \n",
      "Valid Epoch # 1900/2200 Loss: 6.2132e-03 \n",
      "Adam  Epoch # 2000/2200 Loss: 5.6844e-03 = 4.2412e-03 + 1 * 1.4432e-03 lr: 3.43e-04 \n",
      "Valid Epoch # 2000/2200 Loss: 5.6793e-03 \n",
      "LBFGS Epoch # 2020/2200 Loss: 3.09e-04 = 2.94e-04 + 1 * 7.91e-01 \n",
      "Valid Epoch # 2020/2200 Loss: 3.0929e-04 \n",
      "LBFGS Epoch # 2040/2200 Loss: 1.02e-04 = 9.72e-05 + 1 * 7.92e-01 \n",
      "Valid Epoch # 2040/2200 Loss: 1.0189e-04 \n",
      "LBFGS Epoch # 2060/2200 Loss: 5.73e-05 = 5.32e-05 + 1 * 7.92e-01 \n",
      "Valid Epoch # 2060/2200 Loss: 5.7308e-05 \n",
      "LBFGS Epoch # 2080/2200 Loss: 3.70e-05 = 3.48e-05 + 1 * 7.92e-01 \n",
      "Valid Epoch # 2080/2200 Loss: 3.7027e-05 \n",
      "LBFGS Epoch # 2100/2200 Loss: 2.73e-05 = 2.49e-05 + 1 * 7.92e-01 \n",
      "Valid Epoch # 2100/2200 Loss: 2.7296e-05 \n",
      "LBFGS Epoch # 2120/2200 Loss: 2.02e-05 = 1.94e-05 + 1 * 7.92e-01 \n",
      "Valid Epoch # 2120/2200 Loss: 2.0166e-05 \n",
      "LBFGS Epoch # 2140/2200 Loss: 1.52e-05 = 1.44e-05 + 1 * 7.92e-01 \n",
      "Valid Epoch # 2140/2200 Loss: 1.5173e-05 \n",
      "LBFGS Epoch # 2160/2200 Loss: 1.20e-05 = 1.15e-05 + 1 * 7.92e-01 \n",
      "Valid Epoch # 2160/2200 Loss: 1.2010e-05 \n",
      "LBFGS Epoch # 2180/2200 Loss: 9.91e-06 = 9.48e-06 + 1 * 7.92e-01 \n",
      "Valid Epoch # 2180/2200 Loss: 9.9052e-06 \n",
      "LBFGS Epoch # 2200/2200 Loss: 8.07e-06 = 7.77e-06 + 1 * 7.92e-01 \n",
      "Valid Epoch # 2200/2200 Loss: 8.0732e-06 \n"
     ]
    }
   ],
   "source": [
    "# 使用Trainer_Schrodinger进行训练\n",
    "args = Options_Schrodinger().parse()\n",
    "args.problem = Problem_Schrodinger()\n",
    "args.model = ResPINN_Schrodinger(2, 2, dim_hidden=args.dim_hidden, res_blocks=args.res_blocks)\n",
    "if args.sample_method == 'uniform':\n",
    "    args.trainset = Trainset_Schrodinger(args.problem, args.n_x, args.n_y, method='uniform')\n",
    "elif args.sample_method == 'lhs':\n",
    "    args.trainset = Trainset_Schrodinger(args.problem, args.n, args.n_bc, method='lhs')\n",
    "\n",
    "args.validset = Trainset_Schrodinger(args.problem, 100, 100, method='uniform')\n",
    "    \n",
    "trainer = Trainer_Schrodinger(args)\n",
    "trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6、测试过程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Tester_Schrodinger(object):\n",
    "    def __init__(self, args):\n",
    "        self.device  = args.device\n",
    "        self.problem = args.problem\n",
    "        self.criterion = nn.MSELoss()\n",
    "        self.model = args.model\n",
    "        model_name = self.model.__class__.__name__\n",
    "        model_path = os.path.join('checkpoints',\n",
    "                                  model_name,\n",
    "                                  'best_model.pth.tar')\n",
    "        best_model = torch.load(model_path)\n",
    "        self.model.load_state_dict(best_model['state_dict'])        \n",
    "        self.model.to(self.device)\n",
    "        self.X, self.t, self.x, self.h_tar = args.testset(verbose='tensor')\n",
    "        if self.device == torch.device(type='cuda'):\n",
    "            self.X = self.X.to(self.device)\n",
    "    \n",
    "    def predict(self):\n",
    "        self.model.eval()\n",
    "        uv_pred, _ = self.model(self.problem, self.X)\n",
    "        uv_pred = uv_pred.detach().cpu().numpy()\n",
    "        uv_pred = np.sqrt(uv_pred[:, [0]] ** 2 + uv_pred[:, [1]] ** 2)\n",
    "        uv_pred = uv_pred.reshape(self.x.shape)\n",
    "        \n",
    "        fig = plt.figure()\n",
    "        ax = fig.add_subplot(131, projection='3d')\n",
    "        ax.plot_surface(self.t, self.x, self.h_tar, cmap=cm.coolwarm)\n",
    "        ax = fig.add_subplot(132, projection='3d')\n",
    "        ax.plot_surface(self.t, self.x, uv_pred, cmap=cm.coolwarm)\n",
    "        ax = fig.add_subplot(133, projection='3d')\n",
    "        ax.plot_surface(self.t, self.x, np.abs(uv_pred-self.h_tar), cmap=cm.coolwarm)\n",
    "        ax.set_xlim(-0.01, 0.01+np.pi/2)\n",
    "        ax.set_ylim(-5.1, 5.1)\n",
    "\n",
    "    def plot(self):\n",
    "        self.model.eval()\n",
    "        uv_pred, _ = self.model(self.problem, self.X)\n",
    "        uv_pred = uv_pred.detach().cpu().numpy()\n",
    "        uv_pred = np.sqrt(uv_pred[:, [0]] ** 2 + uv_pred[:, [1]] ** 2)\n",
    "        h = uv_pred.reshape(self.x.shape)\n",
    "        \n",
    "        fig, ax = plt.subplots(figsize=(10, 9))\n",
    "        ax.axis('off')\n",
    "\n",
    "        gs0 = gridspec.GridSpec(1, 2)\n",
    "        gs0.update(top=1-0.06, bottom=1-1/3, left=0.15, right=0.85, wspace=0)\n",
    "        ax = plt.subplot(gs0[:, :])\n",
    "\n",
    "        H = ax.imshow(h, interpolation='nearest', cmap='YlGnBu', \n",
    "                      extent=problem.domain, \n",
    "                      origin='lower', aspect='auto')\n",
    "        divider = make_axes_locatable(ax)\n",
    "        cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n",
    "        fig.colorbar(H, cax=cax)\n",
    "\n",
    "        ax.set_xlabel('$t$')\n",
    "        ax.set_ylabel('$x$')\n",
    "        ax.set_title('$|h(t,x)|$', fontsize = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x648 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用Tester_Schrodinger进行预测，复现复现文章中的Figure2（只画出预测结果）\n",
    "args = Options_Schrodinger().parse()\n",
    "args.problem = Problem_Schrodinger()\n",
    "\n",
    "args.model = ResPINN_Schrodinger(2, 2, dim_hidden=args.dim_hidden, res_blocks=args.res_blocks)\n",
    "args.testset = Testset_Schrodinger(args.problem, method='ground_truth')  \n",
    "tester = Tester_Schrodinger(args)\n",
    "tester.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
